aggregator.results;
+
+ if (!storeProducts.length) {
+ // throw `Product not found with in ${radiusInMiles}mi range!`;
+ } else {
+ // (4) --- Result Processing
+ storeProducts.forEach((storeProduct) => {
+ if (
+ storeProduct?.productId &&
+ !uniqueProductIds[storeProduct.productId]
+ ) {
+ uniqueProductIds[storeProduct.productId] = true;
+
+ if (typeof storeProduct.storeLocation == 'string') {
+ const location = storeProduct.storeLocation.split(',');
+ storeProduct.storeLocation = {
+ longitude: Number(location[0]),
+ latitude: Number(location[1]),
+ };
+ }
+
+ trimmedStoreProducts.push(storeProduct);
+ }
+ });
+ }
+ } else {
+ throw 'Mandatory fields like userLocation latitude / longitude missing !';
+ }
+
+ return {
+ storeProducts: trimmedStoreProducts,
+ productIds: Object.keys(uniqueProductIds),
+ };
+};
+```
+
+The implementation demonstrates a practical use case for Redis's Geo Location search capabilities, showcasing how to perform proximity searches combined with other filtering criteria (like product name) and present the results in a user-friendly format.
+
+### Front end
+
+Make sure to select `Geo location search` in settings page to enable the feature.
+
+
+
+Within the dashboard, users have the option to select a random zip code and search for products (say titled "puma"). The search results are comprehensively displayed, including essential details such as the product name, available stock quantity, the name of the store, and the distance of the store from the user's selected location.
+
+
+
+## Ready to use Redis for Geo Location search?
+
+Redis's Geo Location search capabilities offer a powerful and efficient way to perform proximity-based queries and analyses.
+
+By leveraging Redis's in-memory data store and specialized geo commands, developers can build scalable, high-performance applications that respond quickly to location-based queries. The integration with the JavaScript ecosystem further simplifies the development process, enabling seamless application development and deployment.
+
+### References
+
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis om Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) : To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/index-solutions.mdx b/docs/howtos/solutions/index-solutions.mdx
new file mode 100644
index 00000000000..113d620e43d
--- /dev/null
+++ b/docs/howtos/solutions/index-solutions.mdx
@@ -0,0 +1,231 @@
+---
+id: index-solutions
+title: Solution Tutorials
+sidebar_label: Overview
+slug: /howtos/solutions
+---
+
+import RedisCard from '@theme/RedisCard';
+
+This page provides a listing of dozens of popular app solution tutorials from Redis.
+
+## Microservices
+
+Learn how to easily build, test and deploy code for common microservice and caching design patterns across different industries using Redis.
+
+
+
+
+
+## Fraud detection
+
+
+
+## Caching architecture
+
+
+
+
+
+## Real-time Inventory
+
+
+
+## Mobile Banking
+
+
+
+## Vectors
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This diagram illustrates the steps taken in the cache-aside pattern when there is a "cache miss." To understand how this works, consider the following process:
+
+1. An application requests data from the backend.
+1. The backend checks to find out if the data is available in Redis.
+1. Data is not found (a cache miss), so the data is fetched from the database.
+1. The data returned from the database is subsequently stored in Redis.
+1. The data is then returned to the application.
+
+### Cache-aside with Redis (cache hit)
+
+Now that you have seen what a "cache miss" looks like, let's cover a "cache hit." Here is the same diagram, but with the "cache hit" steps highlighted in green.
+
+
+
+1. An application requests data from the backend.
+1. The backend checks to find out if the data is available in Redis.
+1. The data is then returned to the application.
+
+The cache-aside pattern is useful when you need to:
+
+1. **Query data frequently**: When you have a large volume of reads (as is the case in an e-commerce application), the cache-aside pattern gives you an immediate performance gain for subsequent data requests.
+1. **Fill the cache on demand**: The cache-aside pattern fills the cache as data is requested rather than pre-caching, thus saving on space and cost. This is useful when it isn't clear what data will need to be cached.
+1. **Be cost-conscious**: Since cache size is directly related to the cost of cache storage in the cloud, the smaller the size, the less you pay.
+
+:::tip
+
+If you use **Redis Cloud** and a database that uses a JDBC driver, you can take advantage of [**Redis Smart Cache**](https://redis.com/blog/redis-smart-cache/), which lets you add caching to an application without changing the code. [**Click here to learn more!**](https://github.com/redis-field-engineering/redis-smart-cache)
+
+:::
+
+## Microservices architecture for an e-commerce application
+
+
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+
+
+## Caching in a microservices application with Redis and primary database (MongoDB/ Postgressql)
+
+In our sample application, the products service publishes an API for filtering products. Here's what a call to the API looks like:
+
+### Get products by filter request
+
+```json title="docs/api/get-products-by-filter.md"
+// POST http://localhost:3000/products/getProductsByFilter
+{
+ "productDisplayName": "puma"
+}
+```
+
+### Get products by filter response (cache miss)
+
+```json {25}
+{
+ "data": [
+ {
+ "productId": "11000",
+ "price": 3995,
+ "productDisplayName": "Puma Men Slick 3HD Yellow Black Watches",
+ "variantName": "Slick 3HD Yellow",
+ "brandName": "Puma",
+ "ageGroup": "Adults-Men",
+ "gender": "Men",
+ "displayCategories": "Accessories",
+ "masterCategory_typeName": "Accessories",
+ "subCategory_typeName": "Watches",
+ "styleImages_default_imageURL": "http://host.docker.internal:8080/images/11000.jpg",
+ "productDescriptors_description_value": "Stylish and comfortable, ...",
+ "createdOn": "2023-07-13T14:07:38.020Z",
+ "createdBy": "ADMIN",
+ "lastUpdatedOn": "2023-07-13T14:07:38.020Z",
+ "lastUpdatedBy": null,
+ "statusCode": 1
+ }
+ //...
+ ],
+ "error": null,
+ "isFromCache": false
+}
+```
+
+### Get products by filter response (cache hit)
+
+```json {6}
+{
+ "data": [
+ //...same data as above
+ ],
+ "error": null,
+ "isFromCache": true // now the data comes from the cache rather DB
+}
+```
+
+### Implementing cache-aside with Redis and primary database (MongoDB/ Postgressql)
+
+The following code shows the function used to search for products in primary database:
+
+```typescript title="server/src/services/products/src/service-impl.ts"
+async function getProductsByFilter(productFilter: Product) {
+ const prisma = getPrismaClient();
+
+ const whereQuery: Prisma.ProductWhereInput = {
+ statusCode: DB_ROW_STATUS.ACTIVE,
+ };
+
+ if (productFilter && productFilter.productDisplayName) {
+ whereQuery.productDisplayName = {
+ contains: productFilter.productDisplayName,
+ mode: 'insensitive',
+ };
+ }
+
+ const products: Product[] = await prisma.product.findMany({
+ where: whereQuery,
+ });
+
+ return products;
+}
+```
+
+You simply make a call to primary database (MongoDB/ Postgressql) to find products based on a filter on the product's `displayName` property. You can set up multiple columns for better fuzzy searching, but we simplified it for the purposes of this tutorial.
+
+Using primary database directly without Redis works for a while, but eventually it slows down. That's why you might use Redis, to speed things up. The cache-aside pattern helps you balance performance with cost.
+
+The basic decision tree for cache-aside is as follows.
+
+When the frontend requests products:
+
+1. Form a hash with the contents of the request (i.e., the search parameters).
+1. Check Redis to see if a value exists for the hash.
+1. Is there a cache hit? If data is found for the hash, it is returned; the process stops here.
+1. Is there a cache miss? When data is not found, it is read out of primary database and subsequently stored in Redis prior to being returned.
+
+Here’s the code used to implement the decision tree:
+
+```typescript title="server/src/services/products/src/routes.ts"
+const getHashKey = (_filter: Document) => {
+ let retKey = '';
+ if (_filter) {
+ const text = JSON.stringify(_filter);
+ retKey = crypto.createHash('sha256').update(text).digest('hex');
+ }
+ return 'CACHE_ASIDE_' + retKey;
+};
+
+router.post(API.GET_PRODUCTS_BY_FILTER, async (req: Request, res: Response) => {
+ const body = req.body;
+ // using node-redis
+ const redis = getNodeRedisClient();
+
+ //get data from redis
+ const hashKey = getHashKey(req.body);
+ const cachedData = await redis.get(hashKey);
+ const docArr = cachedData ? JSON.parse(cachedData) : [];
+
+ if (docArr && docArr.length) {
+ result.data = docArr;
+ result.isFromCache = true;
+ } else {
+ // get data from primary database
+ const dbData = await getProductsByFilter(body); //method shown earlier
+
+ if (body && body.productDisplayName && dbData.length) {
+ // set data in redis (no need to wait)
+ redis.set(hashKey, JSON.stringify(dbData), {
+ EX: 60, // cache expiration in seconds
+ });
+ }
+
+ result.data = dbData;
+ }
+
+ res.send(result);
+});
+```
+
+:::tip
+
+You need to decide what expiry or time to live (TTL) works best for your particular use case.
+
+:::
+
+## Ready to use Redis for query caching?
+
+You now know how to use Redis for caching with one of the most common caching patterns (cache-aside). It's possible to incrementally adopt Redis wherever needed with different strategies/patterns. For more resources on the topic of microservices, check out the links below:
+
+### Additional resources
+
+- Microservices with Redis
+ - [CQRS](/howtos/solutions/microservices/cqrs)
+ - [Interservice communication](/howtos/solutions/microservices/interservice-communication)
+ - [API gateway caching](/howtos/solutions/microservices/api-gateway-caching)
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis om Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) : To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/microservices/common-data/images/design-cart-2.png b/docs/howtos/solutions/microservices/common-data/images/design-cart-2.png
new file mode 100644
index 00000000000..173812accd9
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/design-cart-2.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/images/design-cart.png b/docs/howtos/solutions/microservices/common-data/images/design-cart.png
new file mode 100644
index 00000000000..e97caf2e5b4
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/design-cart.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/images/design-dashboard.png b/docs/howtos/solutions/microservices/common-data/images/design-dashboard.png
new file mode 100644
index 00000000000..8f353798de0
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/design-dashboard.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/images/design-order-history.png b/docs/howtos/solutions/microservices/common-data/images/design-order-history.png
new file mode 100644
index 00000000000..1c1ba3bc0d9
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/design-order-history.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/images/initial-microservices-arch.png b/docs/howtos/solutions/microservices/common-data/images/initial-microservices-arch.png
new file mode 100644
index 00000000000..c17df575d3b
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/initial-microservices-arch.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/images/redis-microservices-arch.png b/docs/howtos/solutions/microservices/common-data/images/redis-microservices-arch.png
new file mode 100644
index 00000000000..ae3d2b8cc15
Binary files /dev/null and b/docs/howtos/solutions/microservices/common-data/images/redis-microservices-arch.png differ
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis-old.mdx b/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis-old.mdx
new file mode 100644
index 00000000000..fe4df59d0ed
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis-old.mdx
@@ -0,0 +1,10 @@
+The e-commerce microservices application discussed in the rest of this tutorial uses the following architecture:
+
+1. `products service`: handles querying products from the database and returning them to the frontend
+1. `orders service`: handles validating and creating orders
+1. `order history service`: handles querying a customer's order history
+1. `payments service`: handles processing orders for payment
+1. `digital identity service`: handles storing digital identity and calculating identity score
+1. `api gateway`: unifies services under a single endpoint
+1. `mongodb`: serves as the primary database, storing orders, order history, products, etc.
+1. `redis`: serves as the **stream processor** and caching database
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis.mdx b/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis.mdx
new file mode 100644
index 00000000000..282a8952980
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-arch-with-redis.mdx
@@ -0,0 +1,16 @@
+The e-commerce microservices application discussed in the rest of this tutorial uses the following architecture:
+
+1. `products service`: handles querying products from the database and returning them to the frontend
+1. `orders service`: handles validating and creating orders
+1. `order history service`: handles querying a customer's order history
+1. `payments service`: handles processing orders for payment
+1. `digital identity service`: handles storing digital identity and calculating identity score
+1. `api gateway`: unifies services under a single endpoint
+1. `mongodb/ postgresql`: serves as the primary database, storing orders, order history, products, etc.
+1. `redis`: serves as the **stream processor** and caching database
+
+:::info
+
+You don't need to use MongoDB/ Postgresql as your primary database in the demo application; you can use other [prisma supported databases](https://www.prisma.io/docs/reference/database-reference/supported-databases) as well. This is just an example.
+
+:::
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-arch.mdx b/docs/howtos/solutions/microservices/common-data/microservices-arch.mdx
new file mode 100644
index 00000000000..cf1e99c84a3
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-arch.mdx
@@ -0,0 +1,14 @@
+Lets take a look at the architecture of the demo application:
+
+1. `products service`: handles querying products from the database and returning them to the frontend
+1. `orders service`: handles validating and creating orders
+1. `order history service`: handles querying a customer's order history
+1. `payments service`: handles processing orders for payment
+1. `api gateway`: unifies the services under a single endpoint
+1. `mongodb/ postgresql`: serves as the write-optimized database for storing orders, order history, products, etc.
+
+:::info
+
+You don't need to use MongoDB/ Postgresql as your write-optimized database in the demo application; you can use other [prisma supported databases](https://www.prisma.io/docs/reference/database-reference/supported-databases) as well. This is just an example.
+
+:::
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-ecommerce-old.mdx b/docs/howtos/solutions/microservices/common-data/microservices-ecommerce-old.mdx
new file mode 100644
index 00000000000..88f06afcf31
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-ecommerce-old.mdx
@@ -0,0 +1,13 @@
+The e-commerce microservices application consists of a frontend, built using [Next.js](https://nextjs.org/) with [TailwindCSS](https://tailwindcss.com/). The application backend uses [Node.js](https://nodejs.org). The data is stored in
+[Redis](https://redis.com/try-free/) and MongoDB. Below you will find screenshots of the frontend of the e-commerce app:
+
+- `Dashboard`: Shows the list of products with search functionality
+
+ 
+
+- `Shopping Cart`: Add products to the cart, then check out using the "Buy Now" button
+ 
+
+- `Order history`: Once an order is placed, the `Orders` link in the top navigation bar shows the order status and history
+
+ 
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-ecommerce.mdx b/docs/howtos/solutions/microservices/common-data/microservices-ecommerce.mdx
new file mode 100644
index 00000000000..62ef1b49cda
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-ecommerce.mdx
@@ -0,0 +1,13 @@
+The e-commerce microservices application consists of a frontend, built using [Next.js](https://nextjs.org/) with [TailwindCSS](https://tailwindcss.com/). The application backend uses [Node.js](https://nodejs.org). The data is stored in
+[Redis](https://redis.com/try-free/) and MongoDB/ Postgressql using [Prisma](https://www.prisma.io/docs/reference/database-reference/supported-databases). Below you will find screenshots of the frontend of the e-commerce app:
+
+- `Dashboard`: Shows the list of products with search functionality
+
+ 
+
+- `Shopping Cart`: Add products to the cart, then check out using the "Buy Now" button
+ 
+
+- `Order history`: Once an order is placed, the `Orders` link in the top navigation bar shows the order status and history
+
+ 
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip-old.mdx b/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip-old.mdx
new file mode 100644
index 00000000000..1de0c9f6156
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip-old.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone --branch v1.0.0 https://github.com/redis-developer/redis-microservices-ecommerce-solutions
+
+:::
diff --git a/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip.mdx b/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip.mdx
new file mode 100644
index 00000000000..c3a5c22dc4a
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/microservices-source-code-tip.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone --branch v4.2.0 https://github.com/redis-developer/redis-microservices-ecommerce-solutions
+
+:::
diff --git a/docs/howtos/solutions/microservices/common-data/redis-enterprise.mdx b/docs/howtos/solutions/microservices/common-data/redis-enterprise.mdx
new file mode 100644
index 00000000000..90bf6b099e0
--- /dev/null
+++ b/docs/howtos/solutions/microservices/common-data/redis-enterprise.mdx
@@ -0,0 +1,13 @@
+You can use **Redis Cloud** as a multi-model primary database. Redis Cloud is a fully managed, highly available, secure, and real-time data platform. It can store data on both RAM or **Flash**. It also supports **Active-Active** (multi-zone read and write replicas) on different cloud vendors, providing extreme high availability and scalability. Active-Active offers global scalability while maintaining local speed for database reads and writes.
+
+Redis Cloud has many built-in modular capabilities, making it a unified, real-time data platform. Redis Cloud is far more than a document database.
+
+- **JSON**: Persists JSON documents
+- **Search**: Indexes and searches JSON documents
+- **Probabilistic data structures**: Provides bloom filters and other probabilistic data structures
+- **Time Series**: Supports time series data structures
+- **Triggers and Functions**: Syncs data to external databases via different pattern (write-behind/ write-through) or executes custom logic.
+
+Use [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to view your Redis data or to play with raw Redis commands in the workbench.
+
+If you're interested in diving deeper, try [Redis Cloud](https://redis.com/try-free) today for free!
diff --git a/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-cdc.png b/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-cdc.png
new file mode 100644
index 00000000000..94cb112fed3
Binary files /dev/null and b/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-cdc.png differ
diff --git a/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-redis.png b/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-redis.png
new file mode 100644
index 00000000000..7f821d03dba
Binary files /dev/null and b/docs/howtos/solutions/microservices/cqrs/images/cqrs-architecture-with-redis.png differ
diff --git a/docs/howtos/solutions/microservices/cqrs/images/cqrs-pattern.png b/docs/howtos/solutions/microservices/cqrs/images/cqrs-pattern.png
new file mode 100644
index 00000000000..4ce74c90ec3
Binary files /dev/null and b/docs/howtos/solutions/microservices/cqrs/images/cqrs-pattern.png differ
diff --git a/docs/howtos/solutions/microservices/cqrs/images/redis-1-order-with-products.png b/docs/howtos/solutions/microservices/cqrs/images/redis-1-order-with-products.png
new file mode 100644
index 00000000000..dea925a1238
Binary files /dev/null and b/docs/howtos/solutions/microservices/cqrs/images/redis-1-order-with-products.png differ
diff --git a/docs/howtos/solutions/microservices/cqrs/index-cqrs.mdx b/docs/howtos/solutions/microservices/cqrs/index-cqrs.mdx
new file mode 100644
index 00000000000..5edc3ca0327
--- /dev/null
+++ b/docs/howtos/solutions/microservices/cqrs/index-cqrs.mdx
@@ -0,0 +1,344 @@
+---
+id: index-solutions-cqrs
+title: How to Build an E-Commerce App Using Redis with the CQRS Pattern
+sidebar_label: How to Build an E-Commerce App Using Redis with the CQRS Pattern
+slug: /howtos/solutions/microservices/cqrs
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import MicroservicesEcommerceDesign from '../common-data/microservices-ecommerce.mdx';
+import InitialMicroservicesArchitecture from '../common-data/microservices-arch.mdx';
+import SourceCode from '../common-data/microservices-source-code-tip.mdx';
+import RedisCloud from '../common-data/redis-enterprise.mdx';
+
+import cqrsPattern from './images/cqrs-pattern.png';
+import cqrsArchitectureWithCdc from './images/cqrs-architecture-with-cdc.png';
+import imageSampleOrder from './images/redis-1-order-with-products.png';
+
+
+
+
+
+## What is command and query responsibility segregation (CQRS)?
+
+Command Query Responsibility Segregation (CQRS) is a critical pattern within a microservice architecture. It decouples reads (queries) and writes (commands), which permits read and write workloads to work independently.
+
+Commands(write) focus on higher durability and consistency, while queries(read) focus on performance. This enables a microservice to write data to a slower system of record disk-based database, while pre-fetching and caching that data in a cache for real-time reads.
+
+The idea is simple: you separate commands such as "Order this product" (a write operation) from queries such as "Show me my order history" (a read operation). CQRS applications are often messaging-based and rely on [eventual consistency](https://en.wikipedia.org/wiki/Eventual_consistency).
+
+The sample data architecture that follows demonstrates how to use Redis with CQRS:
+
+
+
+The architecture illustrated in the diagram uses the Change Data Capture pattern (noted as "Integrated CDC") to track the changed state on the command database and to replicate it to the query database (Redis). This is a common pattern used with CQRS.
+
+Implementing CDC requires:
+
+1. Taking the data snapshot from the system of record
+1. Performing an ETL operation finalized to load the data on the target cache database
+1. Setting up a mechanism to continuously stream the changes in the system of record to the cache
+
+:::tip
+
+While you can implement your own CDC mechanism with Redis using Triggers and Functions, Redis Cloud comes with its own integrated CDC mechanism to solve this problem for you.
+
+:::
+
+## Why you might use CQRS
+
+> _To improve application performance, scale your read and write operations separately._
+
+Consider the following scenario: You have an e-commerce application that allows a customer to populate a shopping cart with products. The site has a "Buy Now" button to facilitate ordering those products. When first starting out, you might set up and populate a product database (perhaps a SQL database). Then you might write a backend API to handle the processes of creating an order, creating an invoice, processing payments, handling fulfillment, and updating the customer's order history… all in one go.
+
+This method of synchronous order processing seemed like a good idea. But you soon find out that your database slows down as you gain more customers and have a higher sales volume. In reality, most applications have significantly more reads than writes. You should scale those operations separately.
+
+You decide that you need to process orders quickly so the customer doesn't have to wait. Then, when you have time, you can create an invoice, process payment, handle fulfillment, etc.
+
+So you decide to separate each of these steps. Using a microservices approach with CQRS allows you to scale your reads and writes independently as well as aid in decoupling your microservices. With a CQRS model, a single service is responsible for handling an entire command from end to end. One service should not depend on another service in order to complete a command.
+
+## Microservices CQRS architecture for an e-commerce application
+
+
+
+## Using CQRS in a microservices architecture
+
+Note that in the current architecture all the services use the same underlying database. Even though you’re technically separating reads and writes, you can't scale the write-optimized database independently. This is where Redis comes in. If you put Redis in front of your write-optimized database, you can use it for reads while writing to the write-optimized database. The benefit of Redis is that it’s fast for reads and writes, which is why it’s the best choice for caching and CQRS.
+
+:::info
+
+For the purposes of this tutorial, we’re not highlighting how communication is coordinated between our services, such as how new orders are processed for payment. That process uses Redis Streams, and is outlined in our [interservice communication guide](/howtos/solutions/microservices/interservice-communication).
+
+:::
+
+:::tip
+
+When your e-commerce application eventually needs to scale across the globe, Redis Cloud provides Active-Active geo-distribution for reads and writes at local latencies as well as availability of 99.999% uptime.
+
+:::
+
+Let's look at some sample code that helps facilitate the CQRS pattern with Redis and Primary database (MongoDB/ Postgressql).
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+
+
+## Building a CQRS microservices application with Redis and Primary database (MongoDB/ Postgressql)
+
+Let's look at the sample code for the `order service` and see the `CreateOrder` command (a write operation). Then we look at the `order history service` to see the `ViewOrderHistory` command (a read operation).
+
+### Create order command API
+
+The code that follows shows an example API request and response to create an order.
+
+#### Create order request
+
+```json title="docs/api/create-order.md"
+// POST http://api-gateway/orders/createOrder
+{
+ "products": [
+ {
+ "productId": "11002",
+ "qty": 1,
+ "productPrice": 4950
+ },
+ {
+ "productId": "11012",
+ "qty": 2,
+ "productPrice": 1195
+ }
+ ]
+}
+```
+
+#### Create order response
+
+```json
+{
+ "data": "d4075f43-c262-4027-ad25-7b1bc8c490b6", //orderId
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the `orders service`. Ultimately, it ends up calling a `createOrder` function which looks as follows:
+
+```typescript title="server/src/services/orders/src/service-impl.ts"
+const createOrder = async (
+ order: IOrder,
+ //...
+) => {
+ if (!order) {
+ throw 'Order data is mandatory!';
+ }
+
+ const userId = order.userId || USERS.DEFAULT; // Used as a shortcut, in a real app you would use customer session data to fetch user details
+ const orderId = uuidv4();
+
+ order.orderId = orderId;
+ order.orderStatusCode = ORDER_STATUS.CREATED;
+ order.userId = userId;
+ order.createdBy = userId;
+ order.statusCode = DB_ROW_STATUS.ACTIVE;
+ order.potentialFraud = false;
+
+ order = await validateOrder(order);
+
+ const products = await getProductDetails(order);
+ addProductDataToOrders(order, products);
+
+ await addOrderToRedis(order);
+
+ await addOrderToPrismaDB(order);
+
+ //...
+
+ return orderId;
+};
+```
+
+:::info
+
+For tutorial simplicity, we add data to both primary database and Redis in the same service (double-write). As mentioned earlier, a common pattern is to have your services write to one database, and then separately use a CDC mechanism to update the other database. For example, you could write directly to Redis, then use **RedisGears** to handle synchronizing Redis and primary database in the background. For the purposes of this tutorial, we don't outline exactly how you might handle synchronization, but instead focus on how the data is stored and accessed in Redis.
+
+:::
+
+:::tip
+
+If you're using **Redis Cloud**, you can take advantage of the **integrated CDC** mechanism to avoid having to roll your own.
+
+:::
+
+Note that in the previous code block we call the `addOrderToRedis` function to store orders in Redis. We use [Redis OM for Node.js](https://github.com/redis/redis-om-node) to store the order entities in Redis. This is what that function looks like:
+
+```typescript title="server/src/services/orders/src/service-impl.ts"
+import { Schema, Repository } from 'redis-om';
+import { getNodeRedisClient } from '../utils/redis/redis-wrapper';
+
+//Redis Om schema for Order
+const schema = new Schema('Order', {
+ orderId: { type: 'string', indexed: true },
+
+ orderStatusCode: { type: 'number', indexed: true },
+ potentialFraud: { type: 'boolean', indexed: false },
+ userId: { type: 'string', indexed: true },
+
+ createdOn: { type: 'date', indexed: false },
+ createdBy: { type: 'string', indexed: true },
+ lastUpdatedOn: { type: 'date', indexed: false },
+ lastUpdatedBy: { type: 'string', indexed: false },
+ statusCode: { type: 'number', indexed: true },
+});
+
+//Redis OM repository for Order (to read, write and remove orders)
+const getOrderRepository = () => {
+ const redisClient = getNodeRedisClient();
+ const repository = new Repository(schema, redisClient);
+ return repository;
+};
+
+//Redis indexes data for search
+const createRedisIndex = async () => {
+ const repository = getRepository();
+ await repository.createIndex();
+};
+
+const addOrderToRedis = async (order: OrderWithIncludes) => {
+ if (order) {
+ const repository = getOrderRepository();
+ //insert Order in to Redis
+ await repository.save(order.orderId, order);
+ }
+};
+```
+
+Sample **Order** view using [RedisInsight](https://redis.com/redis-enterprise/redis-insight/)
+
+
+
+:::tip
+Download [**RedisInsight**](https://redis.com/redis-enterprise/redis-insight/) to view your Redis data or to play with raw Redis commands in the workbench.
+:::
+
+### Order history API
+
+The code that follows shows an example API request and response to get a customer's order history.
+
+#### Order history request
+
+```json title="docs/api/view-order-history.md"
+// GET http://api-gateway/orderHistory/viewOrderHistory
+```
+
+#### Order history response
+
+```json
+{
+ "data": [
+ {
+ "orderId": "d4075f43-c262-4027-ad25-7b1bc8c490b6",
+ "userId": "USR_22fcf2ee-465f-4341-89c2-c9d16b1f711b",
+ "orderStatusCode": 4,
+ "products": [
+ {
+ "productId": "11002",
+ "qty": 1,
+ "productPrice": 4950,
+ "productData": {
+ "productId": "11002",
+ "price": 4950,
+ "productDisplayName": "Puma Men Race Black Watch",
+ "variantName": "Race 85",
+ "brandName": "Puma",
+ "ageGroup": "Adults-Men",
+ "gender": "Men",
+ "displayCategories": "Accessories",
+ "masterCategory_typeName": "Accessories",
+ "subCategory_typeName": "Watches",
+ "styleImages_default_imageURL": "http://host.docker.internal:8080/images/11002.jpg",
+ "productDescriptors_description_value": "
This watch from puma comes in a heavy duty design. The assymentric dial and chunky..."
+ }
+ },
+ {
+ "productId": "11012",
+ "qty": 2,
+ "productPrice": 1195,
+ "productData": {
+ "productId": "11012",
+ "price": 1195,
+ "productDisplayName": "Wrangler Women Frill Check Multi Tops",
+ "variantName": "FRILL CHECK",
+ "brandName": "Wrangler",
+ "ageGroup": "Adults-Women",
+ "gender": "Women",
+ "displayCategories": "Sale and Clearance,Casual Wear",
+ "masterCategory_typeName": "Apparel",
+ "subCategory_typeName": "Topwear",
+ "styleImages_default_imageURL": "http://host.docker.internal:8080/images/11012.jpg",
+ "productDescriptors_description_value": "
Composition
Navy blue, red, yellow and white checked top made of 100% cotton, with a jabot collar, buttoned ..."
+ }
+ }
+ ],
+ "createdBy": "USR_22fcf2ee-465f-4341-89c2-c9d16b1f711b",
+ "lastUpdatedOn": "2023-07-13T14:11:49.997Z",
+ "lastUpdatedBy": "USR_22fcf2ee-465f-4341-89c2-c9d16b1f711b"
+ }
+ ],
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the `order history service`. Ultimately, it ends up calling a `viewOrderHistory` function, which looks as follows:
+
+```typescript title="server/src/services/order-history/src/service-impl.ts"
+const viewOrderHistory = async (userId: string) => {
+ const repository = OrderRepo.getRepository();
+ let orders: Partial[] = [];
+ const queryBuilder = repository
+ .search()
+ .where('createdBy')
+ .eq(userId)
+ .and('orderStatusCode')
+ .gte(ORDER_STATUS.CREATED) //returns CREATED and PAYMENT_SUCCESS
+ .and('statusCode')
+ .eq(DB_ROW_STATUS.ACTIVE);
+
+ console.log(queryBuilder.query);
+ orders = []>await queryBuilder.return.all();
+};
+```
+
+:::info
+
+Note that the `order history service` only needs to go to Redis for all orders. This is because we handle storage and synchronization between Redis and primary database within the `orders service`.
+
+:::
+
+You might be used to using Redis as a cache and both storing and retrieving stringified JSON values or perhaps hashed values. However, look closely at the code above. In it, we store orders as **JSON** documents, and then use [Redis OM](https://github.com/redis/redis-om-node) to search for the orders that belong to a specific user. Redis operates like a search engine, here, with the ability to speed up queries and scale independently from the primary database (which in this case is MongoDB/ Postgressql).
+
+## Ready to use Redis with the CQRS pattern?
+
+Hopefully, this tutorial has helped you visualize how to use Redis with the CQRS pattern. It can help to reduce the load on your primary database while still allowing you to store and search JSON documents. For additional resources related to this topic, check out the links below:
+
+### Additional resources
+
+- Microservices with Redis
+ - [Interservice communication](/howtos/solutions/microservices/interservice-communication)
+ - [Query caching](/howtos/solutions/microservices/caching)
+ - [API gateway caching](/howtos/solutions/microservices/api-gateway-caching)
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis om Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) : To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/microservices/interservice-communication/images/02-orders-stream.png b/docs/howtos/solutions/microservices/interservice-communication/images/02-orders-stream.png
new file mode 100644
index 00000000000..45a2a43ddb8
Binary files /dev/null and b/docs/howtos/solutions/microservices/interservice-communication/images/02-orders-stream.png differ
diff --git a/docs/howtos/solutions/microservices/interservice-communication/images/04-payments-stream.png b/docs/howtos/solutions/microservices/interservice-communication/images/04-payments-stream.png
new file mode 100644
index 00000000000..4c410fc7697
Binary files /dev/null and b/docs/howtos/solutions/microservices/interservice-communication/images/04-payments-stream.png differ
diff --git a/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-event-flow-diagram.png b/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-event-flow-diagram.png
new file mode 100644
index 00000000000..c89ea49dcc5
Binary files /dev/null and b/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-event-flow-diagram.png differ
diff --git a/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-redis-streams.png b/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-redis-streams.png
new file mode 100644
index 00000000000..608f5889003
Binary files /dev/null and b/docs/howtos/solutions/microservices/interservice-communication/images/interservice-communication-redis-streams.png differ
diff --git a/docs/howtos/solutions/microservices/interservice-communication/index-interservice-communication.mdx b/docs/howtos/solutions/microservices/interservice-communication/index-interservice-communication.mdx
new file mode 100644
index 00000000000..7b81b848fbf
--- /dev/null
+++ b/docs/howtos/solutions/microservices/interservice-communication/index-interservice-communication.mdx
@@ -0,0 +1,403 @@
+---
+id: index-solutions-interservice-communication
+title: Microservices Communication with Redis Streams
+sidebar_label: Microservices Communication with Redis Streams
+slug: /howtos/solutions/microservices/interservice-communication
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import MicroservicesEcommerceDesign from '../common-data/microservices-ecommerce-old.mdx';
+import MicroservicesArchitectureWithRedis from '../common-data/microservices-arch-with-redis-old.mdx';
+import SourceCode from '../common-data/microservices-source-code-tip-old.mdx';
+import RedisCloud from '../common-data/redis-enterprise.mdx';
+
+
+
+
+
+## What is interservice communication?
+
+When building a microservices application, people use a variety of options for communication between services. Among them:
+
+1. **Publish/Subscribe** model: In the pub/sub model (fire and forget), a publisher produces messages, and subscribers that are _active at the time_ consume those messages. Inactive subscribers cannot receive the messages at a later point in time.
+1. **Streaming**: Most microservices applications use an event-streaming solution because of:
+ - **Message persistence**: Unlike the pub/sub model, messages stored in streams can be read by multiple consumers at any time; they fan out. So consumers can read messages at a later point in time, even if they were not active when the message was originally appended to the stream.
+ - **Inherent replayability**: Even if a subscriber crashes during the message processing, it can re-read the exact same unacknowledged message from the stream. For example, say the crashed subscriber never comes back online; the consumer group feature allows consumers to process unacknowledged messages of other consumers after a specified time.
+ - **Separation of concerns**: Producers can produce messages to stream at **high speed** separately and consumers can process messages at their own speed separately. This separation of concerns solves both the "fast producer -> slow consumer" and "slow producer -> fast consumer" problem, allowing for the scaling of those services independently.
+
+In an event-driven microservices architecture, you might have some services that publish an API, and other services that are simply producers and consumers of events with no external API.
+
+## Why you should use Redis for interservice communication
+
+Consider the following scenario: You have an e-commerce application with an architecture that is broken down into different microservices including as `create an order`, `create an invoice`, `process a payment`, `fulfill and order`, and so on. Microservices allow you to separate these commands into different services to scale independently, enabling more customers to get their orders processed quickly and simultaneously, which results in a better user experience, higher sales volume, and less-cranky customer service staff.
+
+When you use microservices, you need a tool for interservice communication. Initially, you might consider using a product like **Kafka** for streaming, but setting it up is rather complicated. What many people don't know about Redis is that it supports streams in the same way Kafka does. Given that you are likely already using Redis for caching, it makes sense to also use it for stream processing. To reduce the complexity of application architecture and maintenance, **Redis** is a great option for interservice communication. Here we break down the process of using Redis with streams for interservice communication.
+
+## Microservices architecture for an e-commerce application
+
+
+
+This diagram illustrates how Redis Streams is used as the message broker between the `orders service` and the `payments service`:
+
+
+
+:::tip
+
+Redis Streams is more cost-effective than using Kafka or other similar technologies.
+With sub-millisecond latency and a lightweight Streams log data structure, Redis is easier to deploy, develop, and operate.
+:::
+
+## Using Redis for interservice communication in an event-driven architecture
+
+The following event flow diagram illustrates how the `orders service` and `payments service` communicate through Redis with streams:
+
+
+
+Let's outline the streams and events used below:
+
+1. The `orders service` inserts order data into the database.
+
+ ```json
+ //sample order data
+ {
+ "orderId": "01GTP3K2TZQQCQ0T2G43DSSMTD",
+ "products": [
+ {
+ "productId": 11000,
+ "qty": 3,
+ "productPrice": 3995,
+ "productData": {
+ "productDisplayName": "Puma Men Slick 3HD Yellow Black Watches",
+ "variantName": "Slick 3HD Yellow",
+ "brandName": "Puma",
+ "ageGroup": "Adults-Men",
+ "gender": "Men"
+ //...
+ }
+ },
+ {
+ "productId": 11001,
+ "qty": 2,
+ "productPrice": 5450,
+ "productData": {
+ "productDisplayName": "Puma Men Top Fluctuation Red Black Watches",
+ "variantName": "Top Fluctuation Red",
+ "brandName": "Puma",
+ "ageGroup": "Adults-Men",
+ "gender": "Men"
+ //...
+ }
+ }
+ ],
+ "userId": "USR_4e7acc44-e91e-4c5c-9112-bdd99d799dd3",
+ "orderStatusCode": 1, //order created
+ "createdBy": "USR_4e7acc44-e91e-4c5c-9112-bdd99d799dd3",
+ "statusCode": 1
+ }
+ ```
+
+2. The `orders service` also appends minimal data (orderId, orderAmount, and userId) to the `ORDERS_STREAM` to signal new order creation (i.e., it acts as `PRODUCER` of the `ORDERS_STREAM`).
+
+ 
+
+3. The `payments service` listens to the `ORDERS_STREAM` and processes payments for new orders, then inserts payment data into the database (i.e, it acts as the `CONSUMER` of the `ORDERS_STREAM`).
+
+ ```json
+ //sample payment data
+ {
+ "paymentId": "6403212956a976300afbaac1",
+ "orderId": "01GTP3K2TZQQCQ0T2G43DSSMTD",
+ "orderAmount": 22885,
+ "paidAmount": 22885,
+ "orderStatusCode": 3, //payment successful
+ "userId": "USR_4e7acc44-e91e-4c5c-9112-bdd99d799dd3",
+ "createdOn": {
+ "$date": {
+ "$numberLong": "1677926697841"
+ }
+ },
+ "createdBy": "USR_4e7acc44-e91e-4c5c-9112-bdd99d799dd3",
+ "statusCode": 1
+ }
+ ```
+
+4. The `payments service` appends minimal data (orderId, paymentId, orderStatusCode, and userId) to the `PAYMENTS_STREAM` to signal a new payment (i.e., it acts as the `PRODUCER` of the `PAYMENTS_STREAM`).
+ 
+
+5. The `orders service` listens to the `PAYMENTS_STREAM` and updates the orderStatus and paymentId for orders in the database accordingly as the order payment is fulfilled (i.e., it acts as the `CONSUMER` of the `PAYMENTS_STREAM`).
+
+```json
+{
+ //order collection update
+ "orderId": "01GTP3K2TZQQCQ0T2G43DSSMTD",
+ "paymentId": "6403212956a976300afbaac1",
+ "orderStatusCode": 3 //payment success
+ //...
+}
+```
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+
+
+## Building an interservice communication application with Redis
+
+We use Redis to broker the events sent between the `orders service` and the `payments service`.
+
+### Producer 1 (orders service)
+
+Let's look at some of the code in the orders service to understand how it works:
+
+1. Orders are created.
+2. After order creation, the `orders service` appends minimal data to the `ORDERS_STREAM` to signal new order creation.
+
+```typescript title="server/src/services/orders/src/service-impl.ts"
+const addOrderIdToStream = async (
+ orderId: string,
+ orderAmount: number,
+ userId: string,
+) => {
+ const nodeRedisClient = getNodeRedisClient();
+ if (orderId && nodeRedisClient) {
+ const streamKeyName = 'ORDERS_STREAM';
+ const entry = {
+ orderId: orderId,
+ orderAmount: orderAmount.toFixed(2),
+ userId: userId,
+ };
+ const id = '*'; //* = auto generate
+ //xAdd adds entry to specified stream
+ await nodeRedisClient.xAdd(streamKeyName, id, entry);
+ }
+};
+```
+
+### Consumer 1 (payments service)
+
+3. The `payments service` listens to the `ORDERS_STREAM`
+
+```typescript title="server/src/services/payments/src/service-impl.ts"
+// Below is some code for how you would use Redis to listen for the stream events:
+
+async function listenToStream(
+ onMessage: (message: any, messageId: string) => Promise,
+) {
+ // using node-redis
+ const redis = getNodeRedisClient();
+ const streamKeyName = 'ORDERS_STREAM'; //stream name
+ const groupName = 'ORDERS_CON_GROUP'; // listening consumer group name (custom)
+ const consumerName = 'PAYMENTS_CON'; // listening consumer name (custom)
+ const readMaxCount = 100;
+
+ // Check if the stream group already exists
+ if (!(await redis.exists(streamKeyName))) {
+ const idPosition = '0'; //0 = start, $ = end or any specific id
+ await nodeRedisClient.xGroupCreate(streamKeyName, groupName, idPosition, {
+ MKSTREAM: true,
+ });
+ }
+
+ // setup a loop to listen for stream events
+ while (true) {
+ // read set of messages from different streams
+ const dataArr = await nodeRedisClient.xReadGroup(
+ commandOptions({
+ isolated: true,
+ }),
+ groupName,
+ consumerName,
+ [
+ {
+ // you can specify multiple streams in array
+ key: streamKeyName,
+ id: '>', // Next entry ID that no consumer in this group has read
+ },
+ ],
+ {
+ COUNT: readMaxCount, // Read n entries at a time
+ BLOCK: 0, // block for 0 (infinite) seconds if there are none.
+ },
+ );
+
+ for (let data of dataArr) {
+ for (let messageItem of data.messages) {
+ // process the message received (in our case, perform payment)
+ await onMessage(messageItem.message, messageItem.id);
+
+ // acknowledge individual messages after processing
+ nodeRedisClient.xAck(streamKeyName, groupName, messageItem.id);
+ }
+ }
+ }
+}
+
+// `listenToStream` listens for events and calls the `onMessage` callback to further handle the events.
+listenToStream({
+ onMessage: processPaymentForNewOrders,
+});
+
+const processPaymentForNewOrders: IMessageHandler = async (
+ message,
+ messageId,
+) => {
+ /*
+ message = {
+ orderId: "",
+ orderAmount: "",
+ userId: "",
+ }
+ */
+ // process payment for new orderId and insert "payments" data to database
+};
+```
+
+:::note
+
+There are a few important things to note here:
+
+1. Make sure the stream group doesn't exist prior to creating it.
+1. Use `isolated: true,` in order to use the blocking version of `XREADGROUP` in [isolated execution](https://github.com/redis/node-redis/blob/master/docs/isolated-execution.md) mode.
+1. Acknowledge individual messages after you process them to remove the messages from the pending orders queue and to avoid processing them more than once.
+
+:::
+
+### Producer 2 (payments service)
+
+4. The `payments service` appends minimal data to `PAYMENTS_STREAM` to signal that a payment has been fulfilled.
+
+```typescript title="server/src/services/payments/src/service-impl.ts"
+const addPaymentIdToStream = async (
+ orderId: string,
+ paymentId: string,
+ orderStatus: number,
+ userId: string,
+) => {
+ const nodeRedisClient = getNodeRedisClient();
+ if (orderId && nodeRedisClient) {
+ const streamKeyName = 'PAYMENTS_STREAM';
+ const entry = {
+ orderId: orderId,
+ paymentId: paymentId,
+ orderStatusCode: orderStatus.toString(),
+ userId: userId,
+ };
+ const id = '*'; //* = auto generate
+ //xAdd adds entry to specified stream
+ await nodeRedisClient.xAdd(streamKeyName, id, entry);
+ }
+};
+```
+
+### Consumer 2 (orders service)
+
+5. The `orders service` listens to the `PAYMENTS_STREAM` and updates the order when payments are fulfilled.
+
+```typescript title="server/src/services/orders/src/service-impl.ts"
+//Below is some code for how you would use Redis to listen for the stream events:
+
+async function listenToStream(
+ onMessage: (message: any, messageId: string) => Promise,
+) {
+ // using node-redis
+ const redis = getNodeRedisClient();
+ const streamKeyName = 'PAYMENTS_STREAM'; //stream name
+ const groupName = 'PAYMENTS_CON_GROUP'; //listening consumer group name (custom)
+ const consumerName = 'ORDERS_CON'; //listening consumer name (custom)
+ const readMaxCount = 100;
+
+ // Check if the stream group already exists
+ if (!(await redis.exists(streamKeyName))) {
+ const idPosition = '0'; //0 = start, $ = end or any specific id
+ await nodeRedisClient.xGroupCreate(streamKeyName, groupName, idPosition, {
+ MKSTREAM: true,
+ });
+ }
+
+ // setup a loop to listen for stream events
+ while (true) {
+ // read set of messages from different streams
+ const dataArr = await nodeRedisClient.xReadGroup(
+ commandOptions({
+ isolated: true,
+ }),
+ groupName,
+ consumerName,
+ [
+ {
+ // you can specify multiple streams in array
+ key: streamKeyName,
+ id: '>', // Next entry ID that no consumer in this group has read
+ },
+ ],
+ {
+ COUNT: readMaxCount, // Read n entries at a time
+ BLOCK: 0, // block for 0 (infinite) seconds if there are none.
+ },
+ );
+
+ for (let data of dataArr) {
+ for (let messageItem of data.messages) {
+ //process the message received (in our case, updateOrderStatus)
+ await onMessage(messageItem.message, messageItem.id);
+
+ // acknowledge individual messages after processing
+ nodeRedisClient.xAck(streamKeyName, groupName, messageItem.id);
+ }
+ }
+ }
+}
+
+// `listenToStream` listens for events and calls the `onMessage` callback to further handle the events.
+listenToStream({
+ onMessage: updateOrderStatus,
+});
+
+const updateOrderStatus: IMessageHandler = async (message, messageId) => {
+ /*
+ message = {
+ orderId: "",
+ paymentId: "",
+ orderStatusCode:"",
+ userId: "",
+ }
+ */
+ // updates orderStatus and paymentId in database accordingly for the order which has fulfilled payment
+ // updateOrderStatusInRedis(orderId,paymentId,orderStatusCode,userId)
+ // updateOrderStatusInMongoDB(orderId,paymentId,orderStatusCode,userId)
+};
+```
+
+:::tip
+
+It's a best practice to validate all incoming messages to make sure you can work with them.
+
+:::
+
+For the purposes of our application, we make a call to update the order status in both Redis and primary database in the same service (For simplicity, we are not using any synchronization technique between databases rather focusing on how the data is stored and accessed in Redis). Another common pattern is to have your services write to one database, and then separately use a CDC mechanism to update the other database. For example, you could write directly to Redis, then use **Triggers and Functions** to handle synchronizing Redis and primary database in the background.
+
+:::tip
+
+If you use **Redis Cloud**, you will find that Redis Streams is available on the same multi-tenant data platform you already use for caching. Redis Cloud also has high availability, message persistence, support for multiple clients, and resiliency with primary/secondary data replication… all built in.
+
+:::
+
+## Ready to use Redis for streaming?
+
+That's all there is to it! You now know how to use Redis for streaming as both a producer and a consumer. Hopefully, you can draw some inspiration from this tutorial and apply it to your own event streaming application. For more on this topic, check out the additional resources below:
+
+### Additional resources
+
+- Redis Streams
+ - Explore streams in detail in the [Redis University course on Redis Streams](https://university.redis.com/courses/ru202/)
+ - Check out our e-book on [Understanding Streams in Redis and Kafka: A Visual Guide](https://redis.com/docs/understanding-streams-in-redis-and-kafka-a-visual-guide/)
+- Microservices with Redis
+ - [CQRS](/howtos/solutions/microservices/cqrs)
+ - [Query caching](/howtos/solutions/microservices/caching)
+ - [API gateway caching](/howtos/solutions/microservices/api-gateway-caching)
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis om Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) : To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/images/01-ui-balance-over-time.png b/docs/howtos/solutions/mobile-banking/account-dashboard/images/01-ui-balance-over-time.png
new file mode 100644
index 00000000000..2c7ac23ae76
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/account-dashboard/images/01-ui-balance-over-time.png differ
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/images/02-ui-biggest-spenders.png b/docs/howtos/solutions/mobile-banking/account-dashboard/images/02-ui-biggest-spenders.png
new file mode 100644
index 00000000000..cba80472155
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/account-dashboard/images/02-ui-biggest-spenders.png differ
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/images/03-ui-search-transactions.png b/docs/howtos/solutions/mobile-banking/account-dashboard/images/03-ui-search-transactions.png
new file mode 100644
index 00000000000..22f06e6bd47
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/account-dashboard/images/03-ui-search-transactions.png differ
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/images/04-ui-recent-transactions.png b/docs/howtos/solutions/mobile-banking/account-dashboard/images/04-ui-recent-transactions.png
new file mode 100644
index 00000000000..c23d9d2d2b4
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/account-dashboard/images/04-ui-recent-transactions.png differ
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/images/dashboard.png b/docs/howtos/solutions/mobile-banking/account-dashboard/images/dashboard.png
new file mode 100644
index 00000000000..e04021654d8
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/account-dashboard/images/dashboard.png differ
diff --git a/docs/howtos/solutions/mobile-banking/account-dashboard/index-account-dashboard.mdx b/docs/howtos/solutions/mobile-banking/account-dashboard/index-account-dashboard.mdx
new file mode 100644
index 00000000000..ec1dd6ebd5b
--- /dev/null
+++ b/docs/howtos/solutions/mobile-banking/account-dashboard/index-account-dashboard.mdx
@@ -0,0 +1,219 @@
+---
+id: index-mb-account-dashboard
+title: Mobile Banking Account Dashboard Using Redis
+sidebar_label: Mobile Banking Account Dashboard Using Redis
+slug: /howtos/solutions/mobile-banking/account-dashboard
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+
+import GeneralAdditionalResources from '../common-mb/additional-resources.mdx';
+import MobileBankingSourceCode from '../common-mb/source-code-tip.mdx';
+import MobileBankingDataSeeding from '../common-mb/data-seeding.mdx';
+
+
+
+
+
+## What is a mobile banking account dashboard?
+
+An account dashboard is a page in a mobile banking app that instantly renders account highlights to users. A customer can click on any of the accounts on the dashboard to see the real-time account details, such as latest transactions, mortgage amount they have left to pay, checking and savings, etc.
+
+An account dashboard makes a customer's finances easily visible in one place. It reduces financial complexity for the customer and fosters customer loyalty.
+
+The following diagram is an example data architecture for an account dashboard:
+
+
+
+1. Banks store information in a number of separate databases that support individual banking products
+2. Key customer account details (balances, recent transactions) across the banks product portfolio are prefetched into Redis Cloud using Redis Data Integration (RDI)
+3. Redis Cloud powers customer's account dashboards, enabling mobile banking users to view balances and other high-priority information immediately upon login
+
+## Why you should use Redis for account dashboards in mobile banking
+
+- **Resilience**: Redis Cloud provides resilience with 99.999% uptime and Active-Active Geo Distribution to prevent loss of critical user profile data
+
+- **Scalability**: Redis Cloud provides < 1ms performance at incredibly high scale to ensure apps perform under peak loads
+
+- **JSON Support**: Provides the ability to create and store account information as JSON documents with the < 1ms speed of Redis
+
+- **Querying and Indexing**: Redis Cloud can quickly identify and store data from multiple different databases and index data to make it readily searchable
+
+:::note
+
+Redis Stack supports the **JSON** data type and allows you to index and querying JSON and [**more**](https://redis.io/docs/stack/). So your Redis data is not limited to simple key-value stringified data.
+
+:::
+
+## Building an account dashboard with Redis
+
+
+
+Download the above source code and run following command to start the demo application
+
+```sh
+docker compose up -d
+```
+
+After docker up & running, open [http://localhost:8080/](http://localhost:8080/) url in browser to view application
+
+### Data seeding
+
+
+
+### Balance over time
+
+**Dashboard widget**
+
+
+
+**API endpoint**
+
+| | |
+| ------------- | --------------------------------- |
+| Endpoint | `/transaction/balance` |
+| Code Location | `/routers/transaction-router.js` |
+| Parameters | none |
+| Return value | `[{x: timestamp, y: value}, ...]` |
+
+The balance endpoint leverages [**Time Series**](https://redis.io/docs/stack/timeseries/), It returns the range of all values from the time series object `balance_ts`. The resulting range is converted to an array of objects with each object containing an `x` property containing the timestamp and a `y` property containing the associated value. This endpoint supplies the time series chart with coordinates to plot a visualization of the balance over time.
+
+```js title="app/routers/transaction-router.js"
+const BALANCE_TS = 'balance_ts';
+
+/* fetch transactions up to sometime ago */
+transactionRouter.get('/balance', async (req, res) => {
+ //time series range
+ const balance = await redis.ts.range(
+ BALANCE_TS,
+ Date.now() - 1000 * 60 * 5, //from
+ Date.now(), //to
+ );
+
+ let balancePayload = balance.map((entry) => {
+ return {
+ x: entry.timestamp,
+ y: entry.value,
+ };
+ });
+
+ res.send(balancePayload);
+});
+```
+
+### Biggest spenders
+
+**Dashboard widget**
+
+
+
+**API end point**
+
+| | |
+| ------------- | -------------------------------- |
+| Endpoint | `/transaction//biggestspenders` |
+| Code Location | `/routers/transaction-router.js` |
+| Parameters | none |
+| Return value | `{labels:[...], series:[...] }` |
+
+The biggest spenders endpoint leverages [**sorted sets**](https://redis.io/docs/manual/patterns/indexes/) as a secondary index, It retrieves all members of the sorted set `bigspenders` that have scores greater than zero. The top five or fewer are returned to provide the UI pie chart with data. The labels array contains the names of the biggest spenders and the series array contains the numeric values associated with each member name.
+
+```js title="app/routers/transaction-router.js"
+const SORTED_SET_KEY = 'bigspenders';
+
+/* fetch top 5 biggest spenders */
+transactionRouter.get('/biggestspenders', async (req, res) => {
+ const range = await redis.zRangeByScoreWithScores(
+ SORTED_SET_KEY,
+ 0,
+ Infinity,
+ );
+ let series = [];
+ let labels = [];
+
+ range.slice(0, 5).forEach((spender) => {
+ series.push(parseFloat(spender.score.toFixed(2)));
+ labels.push(spender.value);
+ });
+
+ res.send({ series, labels });
+});
+```
+
+### Search existing transactions
+
+**Dashboard widget**
+
+
+
+**API end point**
+
+| | |
+| ---------------- | -------------------------------- |
+| Endpoint | `/transaction/search` |
+| Code Location | `/routers/transaction-router.js` |
+| Query Parameters | term |
+| Return value | array of results matching term |
+
+The search endpoint leverages [**Search and Query**](https://redis.io/docs/stack/search/), It receives a `term` query parameter from the UI. A [Redis om Node](https://github.com/redis/redis-om-node) query for the fields `description`, `fromAccountName`, and `accountType` will trigger and return results.
+
+```js title="app/routers/transaction-router.js"
+transactionRouter.get('/search', async (req, res) => {
+ const term = req.query.term;
+
+ let results;
+
+ if (term.length >= 3) {
+ results = await bankRepo
+ .search()
+ .where('description')
+ .matches(term)
+ .or('fromAccountName')
+ .matches(term)
+ .or('transactionType')
+ .equals(term)
+ .return.all({ pageSize: 1000 });
+ }
+ res.send(results);
+});
+```
+
+### Get recent transactions
+
+**Dashboard widget**
+
+
+
+**API end point**
+
+| | |
+| ------------- | -------------------------------- |
+| Endpoint | `/transaction/transactions` |
+| Code Location | `/routers/transaction-router.js` |
+| Parameters | none |
+| Return value | array of results |
+
+Even the transactions endpoint leverages [**Search and Query**](https://redis.io/docs/stack/search/). A [Redis om Node](https://github.com/redis/redis-om-node) query will trigger and return ten most recent transactions.
+
+```js title="app/routers/transaction-router.js"
+/* return ten most recent transactions */
+transactionRouter.get('/transactions', async (req, res) => {
+ const transactions = await bankRepo
+ .search()
+ .sortBy('transactionDate', 'DESC')
+ .return.all({ pageSize: 10 });
+
+ res.send(transactions.slice(0, 10));
+});
+```
+
+## Ready to use Redis in account dashboard?
+
+Hopefully, this tutorial has helped you visualize how to use Redis for account dashboard, specifically in the context of mobile banking. For additional resources related to this topic, check out the links below:
+
+### Additional resources
+
+- [Mobile Banking Session Management](/howtos/solutions/mobile-banking/session-management)
+
+
diff --git a/docs/howtos/solutions/mobile-banking/common-mb/additional-resources.mdx b/docs/howtos/solutions/mobile-banking/common-mb/additional-resources.mdx
new file mode 100644
index 00000000000..a12a7c8e84c
--- /dev/null
+++ b/docs/howtos/solutions/mobile-banking/common-mb/additional-resources.mdx
@@ -0,0 +1,4 @@
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis OM Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/): To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/mobile-banking/common-mb/data-seeding.mdx b/docs/howtos/solutions/mobile-banking/common-mb/data-seeding.mdx
new file mode 100644
index 00000000000..d6a4d3de8ce
--- /dev/null
+++ b/docs/howtos/solutions/mobile-banking/common-mb/data-seeding.mdx
@@ -0,0 +1,76 @@
+This application leverages **Redis core data structures, JSON, TimeSeries, Search and Query features**. The data seeded is later used to show a searchable transaction overview with realtime updates as well as a personal finance management overview with realtime balance and biggest spenders updates.
+
+On application startup in `app/server.js`, a cron is scheduled to create random bank transactions at regular intervals and seed those transactions in to Redis.
+
+```js title="app/server.js"
+//cron job to trigger createBankTransaction() at regular intervals
+
+cron.schedule('*/10 * * * * *', async () => {
+ const userName = process.env.REDIS_USERNAME;
+
+ createBankTransaction(userName);
+
+ //...
+});
+```
+
+- The transaction generator creates a randomized banking debit or credit which will reflect on a (default) starting user balance of $100,000.00
+- The **transaction data** is saved as a JSON document within Redis.
+- To capture **balance over time**, the `balanceAfter` value is recorded in a TimeSeries with the key `balance_ts` for every transaction.
+- To track **biggest spenders**, an associated **`fromAccountName`** member within the sorted set `bigspenders` is incremented by the transaction amount. Note that this amount can be positive or negative.
+
+```js title="app/transactions/transactionsGenerator.js"
+let balance = 100000.0;
+const BALANCE_TS = 'balance_ts';
+const SORTED_SET_KEY = 'bigspenders';
+
+export const createBankTransaction = async () => {
+ //to create random bank transaction
+ let vendorsList = source.source; //app/transactions/transaction_sources.js
+ const random = Math.floor(Math.random() * 9999999999);
+
+ const vendor = vendorsList[random % vendorsList.length]; //random vendor from the list
+
+ const amount = createTransactionAmount(vendor.fromAccountName, random);
+ const transaction = {
+ id: random * random,
+ fromAccount: Math.floor((random / 2) * 3).toString(),
+ fromAccountName: vendor.fromAccountName,
+ toAccount: '1580783161',
+ toAccountName: 'bob',
+ amount: amount,
+ description: vendor.description,
+ transactionDate: new Date(),
+ transactionType: vendor.type,
+ balanceAfter: balance,
+ };
+
+ //redis json feature
+ const bankTransaction = await bankTransactionRepository.save(transaction);
+ console.log('Created bankTransaction!');
+ // ...
+};
+
+const createTransactionAmount = (vendor, random) => {
+ let amount = createAmount(); //random amount
+ balance += amount;
+ balance = parseFloat(balance.toFixed(2));
+
+ //redis time series feature
+ redis.ts.add(BALANCE_TS, '*', balance, { DUPLICATE_POLICY: 'first' });
+ //redis sorted set as secondary index
+ redis.zIncrBy(SORTED_SET_KEY, amount * -1, vendor);
+
+ return amount;
+};
+```
+
+Sample `bankTransaction` data view using [RedisInsight](https://redis.com/redis-enterprise/redis-insight/)
+
+
+
+
+
+:::tip
+Download [**RedisInsight**](https://redis.com/redis-enterprise/redis-insight/) to view your Redis data or to play with raw Redis commands in the workbench.
+:::
diff --git a/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-data.png b/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-data.png
new file mode 100644
index 00000000000..4e392dc160b
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-data.png differ
diff --git a/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-json.png b/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-json.png
new file mode 100644
index 00000000000..2c68ffc0d6d
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/common-mb/images/bank-transaction-json.png differ
diff --git a/docs/howtos/solutions/mobile-banking/common-mb/source-code-tip.mdx b/docs/howtos/solutions/mobile-banking/common-mb/source-code-tip.mdx
new file mode 100644
index 00000000000..9c810983140
--- /dev/null
+++ b/docs/howtos/solutions/mobile-banking/common-mb/source-code-tip.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone --branch v1.2.0 https://github.com/redis-developer/mobile-banking-solutions
+
+:::
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/auth.png b/docs/howtos/solutions/mobile-banking/session-management/images/auth.png
new file mode 100644
index 00000000000..59f3a985466
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/auth.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-data.png b/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-data.png
new file mode 100644
index 00000000000..4e392dc160b
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-data.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-json.png b/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-json.png
new file mode 100644
index 00000000000..2c68ffc0d6d
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/bank-transaction-json.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/browser-cookie-entry.png b/docs/howtos/solutions/mobile-banking/session-management/images/browser-cookie-entry.png
new file mode 100644
index 00000000000..671e70f25bd
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/browser-cookie-entry.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard-balance-widget.png b/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard-balance-widget.png
new file mode 100644
index 00000000000..27f142eb359
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard-balance-widget.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard.png b/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard.png
new file mode 100644
index 00000000000..ca17959c167
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/demo-dashboard.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/demo-login.png b/docs/howtos/solutions/mobile-banking/session-management/images/demo-login.png
new file mode 100644
index 00000000000..ec6174cf470
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/demo-login.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update.png b/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update.png
new file mode 100644
index 00000000000..bb46e790a6a
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update2.png b/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update2.png
new file mode 100644
index 00000000000..a936c4abcfa
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/session-balance-update2.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/images/session-entry.png b/docs/howtos/solutions/mobile-banking/session-management/images/session-entry.png
new file mode 100644
index 00000000000..d16e65e5723
Binary files /dev/null and b/docs/howtos/solutions/mobile-banking/session-management/images/session-entry.png differ
diff --git a/docs/howtos/solutions/mobile-banking/session-management/index-session-management.mdx b/docs/howtos/solutions/mobile-banking/session-management/index-session-management.mdx
new file mode 100644
index 00000000000..e8c3db1ca65
--- /dev/null
+++ b/docs/howtos/solutions/mobile-banking/session-management/index-session-management.mdx
@@ -0,0 +1,199 @@
+---
+id: index-mb-session-management
+title: Mobile Banking Authentication and Session Storage Using Redis
+sidebar_label: Mobile Banking Authentication and Session Storage Using Redis
+slug: /howtos/solutions/mobile-banking/session-management
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+
+import GeneralAdditionalResources from '../common-mb/additional-resources.mdx';
+import MobileBankingSourceCode from '../common-mb/source-code-tip.mdx';
+import MobileBankingDataSeeding from '../common-mb/data-seeding.mdx';
+
+import MobileBankingDashboardBalance from './images/demo-dashboard-balance-widget.png';
+
+
+
+
+
+## What is authentication and session storage for mobile banking?
+
+After a user has successfully entered their login credentials, mobile banking apps use a `token` and `sessionId` created by the server to represent a user's identity. The `token` is stored in Redis for the duration of a user session and also sent in the login response to the banking application client (mobile/ browser). The client application then sends the `token` with every request to server and server validates it before processing the request.
+
+
+
+:::note
+
+Redis Stack supports the **JSON** data type and allows you to index and querying JSON and [**more**](https://redis.io/docs/stack/). So your session store is not limited to simple key-value stringified data.
+
+:::
+
+The session store houses critical information related to each user as they navigate an application for the duration of their session. Mobile banking session data may include, but is not limited to following information:
+
+- User's profile information, such as name, date of birth, email address, etc.
+- User's permissions, such as `user`, `admin`, `supervisor`, `super-admin`, etc.
+- Other app-related data like recent transaction(s), balance etc.
+- Session expiration, such as one hour from now, one week from now, etc.
+
+## Why you should use Redis for mobile banking session management?
+
+- **Resilience**: Redis Cloud offers incredible resilience with **99.999% uptime**. After all, authentication token stores must provide round-the-clock availability. This ensures that users get uninterrupted, 24/7 access to their applications.
+
+- **Scalability**: Token stores need to be highly scalable so that they don't become a bottleneck when a **high volume of users** authenticate at once. Redis Cloud provides **< 1ms latency** at incredibly high throughput (up to **100MM ops/second**) which makes authentication and session data access much faster!
+
+- **Integration with common libraries and platforms**: Since Redis open source is integrated into most session management libraries and platforms, Redis Cloud can seamlessly integrate when upgrading from open source Redis (e.g. `express-session` and [`connect-redis-stack`](https://www.npmjs.com/package/connect-redis-stack) libraries integration is demonstrated in this tutorial)
+
+:::tip
+
+Read our ebook that answers the question: [**Are JSON Web Tokens (JWT) Safe?**](https://redis.com/docs/json-web-tokens-jwts-are-not-safe/) It discusses when and how to safely use JWTs, with battle-tested solutions for session management.
+
+:::
+
+## Building session management with Redis
+
+
+
+Download the above source code and run following command to start the demo application
+
+```sh
+docker compose up
+```
+
+After docker up & running, open [http://localhost:8080/](http://localhost:8080/) url in browser to view application
+
+### Data seeding
+
+
+
+### Session configuration
+
+Redis is integrated into many session management libraries, We will be using [connect-redis-stack](https://www.npmjs.com/package/connect-redis-stack) library for this demo which provides Redis session storage for your
+[express-session](https://www.npmjs.com/package/express-session) application.
+
+The following code illustrates configuring Redis sessions and with `express-session`.
+
+```js title="app/server.js"
+import session from 'express-session';
+import { RedisStackStore } from 'connect-redis-stack';
+
+/* configure your session store */
+const store = new RedisStackStore({
+ client: redis, //redis client
+ prefix: 'redisBank:', //redis key prefix
+ ttlInSeconds: 3600, //session expiry time
+});
+
+const app = express();
+
+// ...
+
+app.use(
+ session({
+ store: store, //using redis store for session
+ resave: false,
+ saveUninitialized: false,
+ secret: '5UP3r 53Cr37', //from env file
+ }),
+);
+
+//...
+app.listen(8080, () => console.log('Listening on port 8080'));
+```
+
+### Login API (Session id generation)
+
+
+
+Let's look at the `/perform_login` API code which is triggered on the click of Login button from [login page](http://localhost:8080/)
+
+Since [connect-redis-stack](https://www.npmjs.com/package/connect-redis-stack) is an express middleware, a session is automatically created at the start of the request, and updated at the end of the HTTP(API) response if `req.session` variable is altered.
+
+```js
+app.post('/perform_login', (req, res) => {
+ let session = req.session;
+ console.log(session);
+ /*
+ Session {
+ cookie: { path: '/', _expires: null, originalMaxAge: null, httpOnly: true }
+ }
+ */
+ //hardcoded user for demo
+ if (req.body.username == 'bob' && req.body.password == 'foobared') {
+ //on successful login (for bob user)
+ session = req.session;
+ session.userid = req.body.username; //create session data
+ res.redirect('/index.html');
+ } else {
+ res.redirect('/auth-login.html');
+ }
+});
+```
+
+In above code - `session.userid` variable is assigned with a value on successful login (for "bob" user), so a session is created in Redis with assigned data and only Redis key (sessionId) is stored in client cookie.
+
+- Dashboard page after successful login
+ 
+
+- Session entry in Redis
+ 
+
+- Open developer tools in Dashboard page to check client cookie `connect.sid` (containing only sessionId)
+ 
+
+Now on every other API request from client, [connect-redis-stack](https://www.npmjs.com/package/connect-redis-stack) library makes sure to load session details from redis to `req.session` variable based on the client cookie (sessionId).
+
+### Balance API (Session storage)
+
+Consider the below `/transaction/balance` API code to demonstrate session storage.
+
+We have to modify the `req.session` variable to update session data.
+Let's add more session data like current balance amount of the user .
+
+```js title="app/routers/transaction-router.js"
+/* fetch all transactions up to an hour ago /transaction/balance */
+transactionRouter.get('/balance', async (req, res) => {
+ const balance = await redis.ts.range(
+ BALANCE_TS,
+ Date.now() - 1000 * 60 * 5,
+ Date.now(),
+ );
+
+ let balancePayload = balance.map((entry) => {
+ return {
+ x: entry.timestamp,
+ y: entry.value,
+ };
+ });
+
+ let session = req.session;
+ if (session.userid && balancePayload.length) {
+ //adding latest BalanceAmount to session
+ session.currentBalanceAmount = balancePayload[balancePayload.length - 1]; //updating session data
+ }
+
+ res.send(balancePayload);
+});
+```
+
+- Updated session entry in Redis with `currentBalanceAmount` field ('x' denoting timestamp and 'y' denoting balance amount at that timestamp)
+ 
+
+- Verify the latest balance amount in the Dashboard UI
+ 
+
+## Ready to use Redis in session management?
+
+Hopefully, this tutorial has helped you visualize how to use Redis for better session management, specifically in the context of mobile banking. For additional resources related to this topic, check out the links below:
+
+### Additional resources
+
+- [Are JSON Web Tokens (JWT) Safe?](https://redis.com/docs/json-web-tokens-jwts-are-not-safe/)
+
+
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-many-skus.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-many-skus.mdx
new file mode 100644
index 00000000000..9de46b156ea
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-many-skus.mdx
@@ -0,0 +1,93 @@
+The code that follows shows an example API request and response for decrementManySKUs activity.
+
+**decrementManySKUs API Request**
+
+```json
+POST http://localhost:3000/api/decrementManySKUs
+[{
+ "sku":1019688,
+ "quantity":4
+},{
+ "sku":1003622,
+ "quantity":2
+},{
+ "sku":1006702,
+ "quantity":2
+}]
+```
+
+**decrementManySKUs API Response**
+
+```json
+{
+ "data": [
+ {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 28 //previous value 32
+ },
+ {
+ "sku": 1003622,
+ "name": "Aquarius - Fender Stratocaster 1,000-Piece Jigsaw Puzzle - Black/Red/White/Yellow/Green/Orange/Blue",
+ "type": "HardGood",
+ "totalQuantity": 8 //previous value 10
+ },
+ {
+ "sku": 1006702,
+ "name": "Clash of the Titans [DVD] [2010]",
+ "type": "Movie",
+ "totalQuantity": 8 //previous value 10
+ }
+ ],
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `decrementManySKUs` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+ static async decrementManySKUs(_productsFilter: IProductBodyFilter[]): Promise {
+ /**
+ decrement quantity of specific Products.
+
+ :param _productWithIds: Product list with Id
+ :return: Product list
+ */
+ let retItems: IProduct[] = [];
+
+ if (_productsFilter && _productsFilter.length) {
+ //validation only
+ const promArr: Promise[] = [];
+ for (let p of _productsFilter) {
+ if (p.sku) {
+ //validating if all products in stock
+ const promObj = InventoryServiceCls.validateQuantityOnDecrementSKU(p.sku, p.quantity);
+ promArr.push(promObj)
+ }
+ }
+ await Promise.all(promArr);
+
+ //decrement only
+ const promArr2: Promise[] = [];
+ for (let p of _productsFilter) {
+ if (p.sku && p.quantity) {
+ const isDecrement = true; //increments with negative value
+ const isReturnProduct = false;
+ const promObj2 = InventoryServiceCls.incrementSKU(p.sku, p.quantity, isDecrement, isReturnProduct);
+ promArr2.push(promObj2)
+ }
+ }
+ await Promise.all(promArr2);
+
+
+ //retrieve updated products
+ retItems = await InventoryServiceCls.retrieveManySKUs(_productsFilter);
+ }
+ else {
+ throw `Input params failed !`;
+ }
+
+ return retItems;
+ }
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-sku.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-sku.mdx
new file mode 100644
index 00000000000..59f50f1db49
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/decrement-sku.mdx
@@ -0,0 +1,73 @@
+The code that follows shows an example API request and response for decrementSKU activity.
+
+**decrementSKU API Request**
+
+```json
+POST http://localhost:3000/api/decrementSKU
+{
+ "sku":1019688,
+ "quantity":4
+}
+```
+
+**decrementSKU API Response**
+
+```json
+{
+ "data": {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 16 //previous value 20
+ },
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `decrementSKU` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+static async decrementSKU(_productId: number, _decrQuantity: number): Promise {
+ /**
+ decrement quantity of a Product.
+
+ :param _productId: Product Id
+ :param _decrQuantity: new decrement quantity
+ :return: Product with Quantity
+ */
+ let retItem: IProduct = {};
+
+ //validating if product in stock
+ let isValid = await InventoryServiceCls.validateQuantityOnDecrementSKU(_productId, _decrQuantity);
+
+ if (isValid) {
+ const isDecrement = true; //increments with negative value
+ const isReturnProduct = true;
+ retItem = await InventoryServiceCls.incrementSKU(_productId, _decrQuantity, isDecrement, isReturnProduct);
+ }
+
+ return retItem;
+ }
+
+ static async validateQuantityOnDecrementSKU(_productId: number, _decrQuantity?: number): Promise {
+ let isValid = false;
+
+ if (!_decrQuantity) {
+ _decrQuantity = 1;
+ }
+
+ if (_productId) {
+ const product = await InventoryServiceCls.retrieveSKU(_productId);
+ if (product && product.totalQuantity && product.totalQuantity > 0
+ && (product.totalQuantity - _decrQuantity >= 0)) {
+
+ isValid = true;
+ }
+ else {
+ throw `For product with Id ${_productId}, available quantity(${product.totalQuantity}) is lesser than decrement quantity(${_decrQuantity})`;
+ }
+
+ }
+ return isValid;
+ }
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/increment-sku.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/increment-sku.mdx
new file mode 100644
index 00000000000..54be0949655
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/increment-sku.mdx
@@ -0,0 +1,66 @@
+The code that follows shows an example API request and response for incrementSKU activity.
+
+**incrementSKU API Request**
+
+```json
+POST http://localhost:3000/api/incrementSKU
+{
+ "sku":1019688,
+ "quantity":2
+}
+```
+
+**incrementSKU API Response**
+
+```json
+{
+ "data": {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 12 //previous value 10
+ },
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `incrementSKU` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+static async incrementSKU(_productId: number, _incrQuantity: number, _isDecrement: boolean, _isReturnProduct: boolean): Promise {
+ /**
+ increment quantity of a Product.
+
+ :param _productId: Product Id
+ :param _incrQuantity: new increment quantity
+ :return: Product with Quantity
+ */
+
+ const redisOmClient = getRedisOmClient();
+ let retItem: IProduct = {};
+
+ if (!_incrQuantity) {
+ _incrQuantity = 1;
+ }
+ if (_isDecrement) {
+ _incrQuantity = _incrQuantity * -1;
+ }
+ if (redisOmClient && _productId && _incrQuantity) {
+
+ const updateKey = `${ProductRepo.PRODUCT_KEY_PREFIX}:${_productId}`;
+
+ //increment json number field by specific (positive/ negative) value
+ await redisOmClient.redis?.json.numIncrBy(updateKey, '$.totalQuantity', _incrQuantity);
+
+ if (_isReturnProduct) {
+ retItem = await InventoryServiceCls.retrieveSKU(_productId);
+ }
+
+ }
+ else {
+ throw `Input params failed !`;
+ }
+
+ return retItem;
+ }
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-many-skus.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-many-skus.mdx
new file mode 100644
index 00000000000..629e8d3082a
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-many-skus.mdx
@@ -0,0 +1,97 @@
+The code that follows shows an example API request and response for retrieveManySKUs activity.
+
+**retrieveManySKUs API Request**
+
+```json
+POST http://localhost:3000/api/retrieveManySKUs
+[{
+ "sku":1019688
+},{
+ "sku":1003622
+},{
+ "sku":1006702
+}]
+```
+
+**retrieveManySKUs API Response**
+
+```json
+{
+ "data": [
+ {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 24
+ },
+ {
+ "sku": 1003622,
+ "name": "Aquarius - Fender Stratocaster 1,000-Piece Jigsaw Puzzle - Black/Red/White/Yellow/Green/Orange/Blue",
+ "type": "HardGood",
+ "totalQuantity": 10
+ },
+ {
+ "sku": 1006702,
+ "name": "Clash of the Titans [DVD] [2010]",
+ "type": "Movie",
+ "totalQuantity": 10
+ }
+ ],
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `retrieveManySKUs` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+static async retrieveManySKUs(_productWithIds: IProductBodyFilter[]): Promise {
+ /**
+ Get current Quantity of specific Products.
+
+ :param _productWithIds: Product list with Id
+ :return: Product list
+ */
+ const repository = ProductRepo.getRepository();
+ let retItems: IProduct[] = [];
+
+ if (repository && _productWithIds && _productWithIds.length) {
+
+ //string id array
+ const idArr = _productWithIds.map((product) => {
+ return product.sku?.toString() || ""
+ });
+
+ //fetch products by IDs (using redis om library)
+ const result = await repository.fetch(...idArr);
+
+ let productsArr: IProduct[] = [];
+
+ if (idArr.length == 1) {
+ productsArr = [result];
+ }
+ else {
+ productsArr = result;
+ }
+
+ if (productsArr && productsArr.length) {
+
+ retItems = productsArr.map((product) => {
+ return {
+ sku: product.sku,
+ name: product.name,
+ type: product.type,
+ totalQuantity: product.totalQuantity
+ }
+ });
+ }
+ else {
+ throw `No products found !`;
+ }
+ }
+ else {
+ throw `Input params failed !`;
+ }
+
+ return retItems;
+ }
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-sku.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-sku.mdx
new file mode 100644
index 00000000000..eef88d0d2bc
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/retrieve-sku.mdx
@@ -0,0 +1,62 @@
+The code that follows shows an example API request and response for retrieveSKU activity.
+
+**retrieveSKU API Request**
+
+```json
+GET http://localhost:3000/api/retrieveSKU?sku=1019688
+```
+
+**retrieveSKU API Response**
+
+```json
+{
+ "data": {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 10
+ },
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `retrieveSKU` function which looks as follows:
+
+**code**
+
+```typescript title="src/inventory-service.ts"
+
+static async retrieveSKU(_productId: number): Promise {
+ /**
+ Get current Quantity of a Product.
+
+ :param _productId: Product Id
+ :return: Product with Quantity
+ */
+ const repository = ProductRepo.getRepository();
+ let retItem: IProduct = {};
+
+ if (repository && _productId) {
+ //fetch product by ID (using redis om library)
+ const product = await repository.fetch(_productId.toString());
+
+ if (product) {
+ retItem = {
+ sku: product.sku,
+ name: product.name,
+ type: product.type,
+ totalQuantity: product.totalQuantity
+ }
+ }
+ else {
+ throw `Product with Id ${_productId} not found`;
+ }
+ }
+ else {
+ throw `Input params failed !`;
+ }
+
+ return retItem;
+}
+
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/api/update-sku.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/update-sku.mdx
new file mode 100644
index 00000000000..e6f3dabd035
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/api/update-sku.mdx
@@ -0,0 +1,69 @@
+The code that follows shows an example API request and response for updateSKU activity.
+
+**updateSKU API Request**
+
+```json
+POST http://localhost:3000/api/updateSKU
+{
+ "sku":1019688,
+ "quantity":25
+}
+```
+
+**updateSKU API Response**
+
+```json
+{
+ "data": {
+ "sku": 1019688,
+ "name": "5-Year Protection Plan - Geek Squad",
+ "type": "BlackTie",
+ "totalQuantity": 25 //updated value
+ },
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling a `updateSKU` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+ static async updateSKU(_productId: number, _quantity: number): Promise {
+ /**
+ Set Quantity of a Product.
+
+ :param _productId: Product Id
+ :param _quantity: new quantity
+ :return: Product with Quantity
+ */
+ const repository = ProductRepo.getRepository();
+ let retItem: IProduct = {};
+
+ if (repository && _productId && _quantity >= 0) {
+ //fetch product by ID (using redis om library)
+ const product = await repository.fetch(_productId.toString());
+
+ if (product) {
+ //update the product fields
+ product.totalQuantity = _quantity;
+
+ // save the modified product
+ const savedItem = await repository.save(product);
+
+ retItem = {
+ sku: savedItem.sku,
+ name: savedItem.name,
+ type: savedItem.type,
+ totalQuantity: savedItem.totalQuantity
+ }
+ }
+ else {
+ throw `Product with Id ${_productId} not found`;
+ }
+ }
+ else {
+ throw `Input params failed !`;
+ }
+
+ return retItem;
+ }
+```
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp.png b/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp.png
new file mode 100644
index 00000000000..6e3e3d43016
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp2.png b/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp2.png
new file mode 100644
index 00000000000..916fccdbf1e
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/available-to-promise/images/atp2.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/available-to-promise/index-rti-available-to-promise.mdx b/docs/howtos/solutions/real-time-inventory/available-to-promise/index-rti-available-to-promise.mdx
new file mode 100644
index 00000000000..05e91a05906
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/available-to-promise/index-rti-available-to-promise.mdx
@@ -0,0 +1,119 @@
+---
+id: index-rti-available-to-promise
+title: Available to Promise in Real-time Inventory Using Redis
+sidebar_label: Available to Promise in Real-time Inventory
+slug: /howtos/solutions/real-time-inventory/available-to-promise
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+
+import RetrieveSKU from './api/retrieve-sku.mdx';
+import UpdateSKU from './api/update-sku.mdx';
+import IncrementSKU from './api/increment-sku.mdx';
+import DecrementSKU from './api/decrement-sku.mdx';
+import RetrieveManySKUs from './api/retrieve-many-skus.mdx';
+import DecrementManySKUs from './api/decrement-many-skus.mdx';
+
+import RealTimeInventorySourceCode from '../common-rti/source-code-tip.mdx';
+import RealTimeInventoryChallenges from '../common-rti/rti-challenges.mdx';
+import RealTimeInventoryCustomerProofs from '../common-rti/customer-proofs.mdx';
+import GeneralAdditionalResources from '../common-rti/additional-resources.mdx';
+
+
+
+
+
+## What is available-to-promise (ATP)?
+
+The major requirement in a **retail inventory system** is presenting an accurate, real-time view of inventory to shoppers and store associates enabling buy-online-pickup-in-store (BOPIS). Optimizing fulfillment from multiple inventory locations.
+
+**Available to promise (ATP)** is the projected amount of inventory left available to sell, not including allocated inventory. It allows businesses to control distribution to their customers and predict inventory. The ATP model helps retailers keep inventory costs down such as ordering costs, carrying costs and stock-out costs. ATP is helpful as long as consumer buying forecasts remain correct. Implementing ATP processes effectively for retailers can mean the difference between sustained growth and an inventory that repeatedly runs out of customer's favorite products missing sales opportunities and harming customer experience.
+
+### How to calculate available-to-promise
+
+Calculating available-to-promise is a relatively simple undertaking. Complete the following formula for an accurate breakdown of available-to-promise capabilities:
+
+```
+Available-to-promise = QuantityOnHand + Supply - Demand
+```
+
+This formula includes the following elements:
+
+- QuantityOnHand: the total number of products that are immediately available to a company
+- Supply: the total stock of a product available for sale
+- Demand: the amount of a specific product that consumers are willing to purchase
+
+## Current challenges in real time inventory
+
+
+
+## Why you should use Redis for available-to-promise
+
+- **Increased inventory visibility**: Redis Cloud provides highly scalable, real-time inventory synchronization between stores providing views into what stock is Available-To-Promise. Customers want to buy from a retailer who can check stock across multiple locations and provide real-time views on what's available locally.
+
+- **Enhanced customer experience**: Sub-millisecond latency means online customers can easily get real-time views of shopping carts, pricing, and in stock availability. Redis Cloud built-in search engine delivers full text and aggregated faceted search of inventory in real time, scaling performance to instantly search inventories with millions of product types helping customers fill their shopping carts faster, keeping them engaged and loyal.
+
+- **Cost efficiency at scale**: Redis Cloud offers real-time, bi-directional consistency between stores and data integration capabilities with enterprise systems without the complexity and costs of managing message brokers, auditing, and reconciliation.
+
+## Real time inventory with Redis
+
+
+
+Using Redis, System delivers real-time synchronization of inventory across stores, in transit and warehouses. Provide retailers the most accurate, timely data on inventory across their entire store network and consumers positive customer experiences searching and locating inventory.
+
+Redis Data Integration (RDI) capabilities enable accurate real-time inventory management and system of record synchronization. Redis advanced inventory search and query capabilities provide accurate available inventory information to multichannel and omnichannel customers and store associates.
+
+This solution increases inventory turnover ratios resulting in lower inventory costs, higher revenue and profits. It also reduces the impact of customer searches on Systems of Record and Inventory Management Systems (IMS).
+
+### Customer proof points
+
+
+
+## Building a real time inventory service with redis
+
+
+
+Managing inventory or a **SKU (stock keeping unit)** process contains some activities like :
+
+1. RetrieveSKU : Fetch the current quantity of a product
+1. UpdateSKU : Update the latest quantity of a product
+1. IncrementSKU : Increment the quantity by a specific value (Say, when more products are procured)
+1. DecrementSKU : Decrement the quantity by a specific value (Say, after order fulfillment of the product)
+1. RetrieveManySKUs : Fetch the current quantity of **multiple** products (Say, to verify products in stock before payment)
+1. DecrementManySKUs: Decrement the quantity of **multiple** products (Say, after an order fulfillment with multiple products)
+
+### RetrieveSKU
+
+
+
+### UpdateSKU
+
+
+
+### IncrementSKU
+
+
+
+### DecrementSKU
+
+
+
+### RetrieveManySKUs
+
+
+
+### DecrementManySKUs
+
+
+
+## Ready to use Redis in a Real time inventory system?
+
+Hopefully, this tutorial has helped you visualize how to use Redis in a Real time inventory system for product availability across different location stores. For additional resources related to this topic, check out the links below:
+
+### Additional resources
+
+- Real time inventory with Redis
+ - [Real time Local Inventory Search](/howtos/solutions/real-time-inventory/local-inventory-search)
+- General
+
diff --git a/docs/howtos/solutions/real-time-inventory/common-rti/additional-resources.mdx b/docs/howtos/solutions/real-time-inventory/common-rti/additional-resources.mdx
new file mode 100644
index 00000000000..9fe1b25724a
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/common-rti/additional-resources.mdx
@@ -0,0 +1,4 @@
+- [Redis YouTube channel](https://www.youtube.com/c/Redisinc)
+- Clients like [Node Redis](https://github.com/redis/node-redis) and [Redis om Node](https://github.com/redis/redis-om-node) help you to use Redis in Node.js applications.
+- [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) : To view your Redis data or to play with raw Redis commands in the workbench
+- [Try Redis Cloud for free](https://redis.com/try-free/)
diff --git a/docs/howtos/solutions/real-time-inventory/common-rti/customer-proofs.mdx b/docs/howtos/solutions/real-time-inventory/common-rti/customer-proofs.mdx
new file mode 100644
index 00000000000..2f2e82fe363
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/common-rti/customer-proofs.mdx
@@ -0,0 +1 @@
+- Redis Cloud on Google Cloud Platform enables [**Ulta Beauty to build a “digital store of the future”**](https://redis.com/customers/ulta-beauty/)
diff --git a/docs/howtos/solutions/real-time-inventory/common-rti/rti-challenges.mdx b/docs/howtos/solutions/real-time-inventory/common-rti/rti-challenges.mdx
new file mode 100644
index 00000000000..8bba0b0e7d0
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/common-rti/rti-challenges.mdx
@@ -0,0 +1,9 @@
+- **Over and under-stocking**: While adopting a multi-channel business model (online & in store), lack of inventory visibility results in over and under-stocking of inventory in different regions and stores.
+
+- Consumers **seek convenience**: The ability to search across regional store locations and pickup merchandise **immediately** rather than wait for shipping is a key differentiator for retailers.
+
+- Consumers **seek speed**: All retailers, even small or family-run, must compete against the **customer experience** of large online retailers like Alibaba, FlipKart, Shopee, and Amazon.
+
+- **High inventory costs**: Retailers seek to lower inventory costs by eliminating missed sales from out-of-stock scenarios which also leads to higher “inventory turnover ratios.”
+
+- **Brand value**: Inaccurate store inventory counts lead to frustrated customers and lower sales. The operational pain will **impact the status quo**.
diff --git a/docs/howtos/solutions/real-time-inventory/common-rti/source-code-tip.mdx b/docs/howtos/solutions/real-time-inventory/common-rti/source-code-tip.mdx
new file mode 100644
index 00000000000..8a58f8671a3
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/common-rti/source-code-tip.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone https://github.com/redis-developer/redis-real-time-inventory-solutions
+
+:::
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search-with-distance.mdx b/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search-with-distance.mdx
new file mode 100644
index 00000000000..721d7fa6e46
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search-with-distance.mdx
@@ -0,0 +1,141 @@
+The code that follows shows an example API request and response for `inventorySearchWithDistance` API:
+
+**inventorySearchWithDistance API Request**
+
+```json title="POST http://localhost:3000/api/inventorySearchWithDistance"
+{
+ "sku": 1019688,
+ "searchRadiusInKm": 500,
+ "userLocation": {
+ "latitude": 42.88023,
+ "longitude": -78.878738
+ }
+}
+```
+
+**inventorySearchWithDistance API Response**
+
+```json title="inventorySearchWithDistance API Response"
+{
+ "data": [
+ {
+ "storeId": "02_NY_ROCHESTER",
+ "storeLocation": {
+ "longitude": -77.608849,
+ "latitude": 43.156578
+ },
+ "sku": "1019688",
+ "quantity": "38",
+ "distInKm": "107.74513"
+ },
+ {
+ "storeId": "05_NY_WATERTOWN",
+ "storeLocation": {
+ "longitude": -75.910759,
+ "latitude": 43.974785
+ },
+ "sku": "1019688",
+ "quantity": "31",
+ "distInKm": "268.86249"
+ },
+ {
+ "storeId": "10_NY_POUGHKEEPSIE",
+ "storeLocation": {
+ "longitude": -73.923912,
+ "latitude": 41.70829
+ },
+ "sku": "1019688",
+ "quantity": "45",
+ "distInKm": "427.90787"
+ }
+ ],
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the inventory service. Ultimately, it ends up calling an `inventorySearchWithDistance` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+/**
+ * Search Product in stores within search radius, Also sort results by distance from current user location to store.
+ *
+ * :param _inventoryFilter: Product Id (sku), searchRadiusInKm and current userLocation
+ * :return: Inventory product list
+ */
+static async inventorySearchWithDistance(_inventoryFilter: IInventoryBodyFilter): Promise {
+ const nodeRedisClient = getNodeRedisClient();
+
+ const repository = StoresInventoryRepo.getRepository();
+ let retItems: IStoresInventory[] = [];
+
+ if (nodeRedisClient && repository && _inventoryFilter?.sku
+ && _inventoryFilter?.userLocation?.latitude
+ && _inventoryFilter?.userLocation?.longitude) {
+
+ const lat = _inventoryFilter.userLocation.latitude;
+ const long = _inventoryFilter.userLocation.longitude;
+ const radiusInKm = _inventoryFilter.searchRadiusInKm || 1000;
+
+ const queryBuilder = repository.search()
+ .where('sku')
+ .eq(_inventoryFilter.sku)
+ .and('quantity')
+ .gt(0)
+ .and('storeLocation')
+ .inRadius((circle) => {
+ return circle
+ .latitude(lat)
+ .longitude(long)
+ .radius(radiusInKm)
+ .kilometers
+ });
+
+ console.log(queryBuilder.query);
+ /* Sample queryBuilder query
+ ( ( (@sku:[1019688 1019688]) (@quantity:[(0 +inf]) ) (@storeLocation:[-78.878738 42.88023 500 km]) )
+ */
+
+ const indexName = `${StoresInventoryRepo.STORES_INVENTORY_KEY_PREFIX}:index`;
+ const aggregator = await nodeRedisClient.ft.aggregate(
+ indexName,
+ queryBuilder.query,
+ {
+ LOAD: ["@storeId", "@storeLocation", "@sku", "@quantity"],
+ STEPS: [{
+ type: AggregateSteps.APPLY,
+ expression: `geodistance(@storeLocation, ${long}, ${lat})/1000`,
+ AS: 'distInKm'
+ }, {
+ type: AggregateSteps.SORTBY,
+ BY: "@distInKm"
+ }]
+ });
+
+ /* Sample command to run query directly on CLI
+ FT.AGGREGATE StoresInventory:index '( ( (@sku:[1019688 1019688]) (@quantity:[(0 +inf]) ) (@storeLocation:[-78.878738 42.88023 500 km]) )' LOAD 4 @storeId @storeLocation @sku @quantity APPLY "geodistance(@storeLocation,-78.878738,42.88043)/1000" AS distInKm SORTBY 1 @distInKm
+ */
+
+ retItems = aggregator.results;
+
+ if (!retItems.length) {
+ throw `Product not found with in ${radiusInKm}km range!`;
+ }
+ else {
+ retItems = retItems.map((item) => {
+ if (typeof item.storeLocation == "string") {
+ const location = item.storeLocation.split(",");
+ item.storeLocation = {
+ longitude: Number(location[0]),
+ latitude: Number(location[1]),
+ }
+ }
+ return item;
+ })
+ }
+ }
+ else {
+ throw `Input params failed !`;
+ }
+ return retItems;
+}
+```
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search.mdx b/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search.mdx
new file mode 100644
index 00000000000..b064b50643d
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/local-inventory-search/api/inventory-search.mdx
@@ -0,0 +1,111 @@
+The code that follows shows an example API request and response for the `inventorySearch` API:
+
+**inventorySearch API Request**
+
+```json title="POST http://localhost:3000/api/inventorySearch"
+{
+ "sku":1019688,
+ "searchRadiusInKm":500,
+ "userLocation": {
+ "latitude": 42.880230,
+ "longitude": -78.878738
+ }
+}
+```
+
+**inventorySearch API Response**
+
+```json
+{
+ "data": [
+ {
+ "storeId": "02_NY_ROCHESTER",
+ "storeLocation": {
+ "longitude": -77.608849,
+ "latitude": 43.156578
+ },
+ "sku": 1019688,
+ "quantity": 38
+ },
+ {
+ "storeId": "05_NY_WATERTOWN",
+ "storeLocation": {
+ "longitude": -75.910759,
+ "latitude": 43.974785
+ },
+ "sku": 1019688,
+ "quantity": 31
+ },
+ {
+ "storeId": "10_NY_POUGHKEEPSIE",
+ "storeLocation": {
+ "longitude": -73.923912,
+ "latitude": 41.70829
+ },
+ "sku": 1019688,
+ "quantity": 45
+ }
+ ],
+ "error": null
+}
+```
+
+When you make a request, it goes through the API gateway to the `inventory service`. Ultimately, it ends up calling an `inventorySearch` function which looks as follows:
+
+```typescript title="src/inventory-service.ts"
+/**
+ * Search Product in stores within search radius.
+ *
+ * :param _inventoryFilter: Product Id (sku), searchRadiusInKm and current userLocation
+ * :return: Inventory product list
+ */
+static async inventorySearch(_inventoryFilter: IInventoryBodyFilter): Promise {
+ const nodeRedisClient = getNodeRedisClient();
+
+ const repository = StoresInventoryRepo.getRepository();
+ let retItems: IStoresInventory[] = [];
+
+ if (nodeRedisClient && repository && _inventoryFilter?.sku
+ && _inventoryFilter?.userLocation?.latitude
+ && _inventoryFilter?.userLocation?.longitude) {
+
+ const lat = _inventoryFilter.userLocation.latitude;
+ const long = _inventoryFilter.userLocation.longitude;
+ const radiusInKm = _inventoryFilter.searchRadiusInKm || 1000;
+
+ const queryBuilder = repository.search()
+ .where('sku')
+ .eq(_inventoryFilter.sku)
+ .and('quantity')
+ .gt(0)
+ .and('storeLocation')
+ .inRadius((circle) => {
+ return circle
+ .latitude(lat)
+ .longitude(long)
+ .radius(radiusInKm)
+ .kilometers
+ });
+
+ console.log(queryBuilder.query);
+ /* Sample queryBuilder query
+ ( ( (@sku:[1019688 1019688]) (@quantity:[(0 +inf]) ) (@storeLocation:[-78.878738 42.88023 500 km]) )
+ */
+
+ retItems = await queryBuilder.return.all();
+
+ /* Sample command to run query directly on CLI
+ FT.SEARCH StoresInventory:index '( ( (@sku:[1019688 1019688]) (@quantity:[(0 +inf]) ) (@storeLocation:[-78.878738 42.88023 500 km]) )'
+ */
+
+
+ if (!retItems.length) {
+ throw `Product not found with in ${radiusInKm}km range!`;
+ }
+ }
+ else {
+ throw `Input params failed !`;
+ }
+ return retItems;
+}
+```
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/inventory-data.png b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/inventory-data.png
new file mode 100644
index 00000000000..cb31b292b8a
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/inventory-data.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/local-search.png b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/local-search.png
new file mode 100644
index 00000000000..2c98a3f0a4f
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/local-search.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/newyork-state.png b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/newyork-state.png
new file mode 100644
index 00000000000..59474b38d88
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/newyork-state.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/product-data.png b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/product-data.png
new file mode 100644
index 00000000000..5908e8c75d6
Binary files /dev/null and b/docs/howtos/solutions/real-time-inventory/local-inventory-search/images/product-data.png differ
diff --git a/docs/howtos/solutions/real-time-inventory/local-inventory-search/index-rti-local-inventory-search.mdx b/docs/howtos/solutions/real-time-inventory/local-inventory-search/index-rti-local-inventory-search.mdx
new file mode 100644
index 00000000000..7dd52113a91
--- /dev/null
+++ b/docs/howtos/solutions/real-time-inventory/local-inventory-search/index-rti-local-inventory-search.mdx
@@ -0,0 +1,122 @@
+---
+id: index-rti-local-inventory-search
+title: Real-time Local Inventory Search Using Redis
+sidebar_label: Real-time Local Inventory Search Using Redis
+slug: /howtos/solutions/real-time-inventory/local-inventory-search
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+
+import InventorySearch from './api/inventory-search.mdx';
+import InventorySearchWithDistance from './api/inventory-search-with-distance.mdx';
+
+import RealTimeInventorySourceCode from '../common-rti/source-code-tip.mdx';
+import RealTimeInventoryChallenges from '../common-rti/rti-challenges.mdx';
+import RealTimeInventoryCustomerProofs from '../common-rti/customer-proofs.mdx';
+import GeneralAdditionalResources from '../common-rti/additional-resources.mdx';
+
+import newYorkState from './images/newyork-state.png';
+
+
+
+
+
+## What is real-time local inventory search?
+
+**Real-time local inventory search** is a method of utilizing advanced product search capabilities across a group of stores or warehouses in a region or geographic area by which a retailer can enhance the customer experience with a localized view of inventory while fulfilling orders from the closest store possible.
+
+Geospatial search of merchandise local to the consumer helps sell stock faster, lowers inventory levels, and thus increases inventory turnover ratio.
+Consumers locate a product online, place the order in their browser or mobile device, and pick up at nearest store location. This is called “buy-online-pickup-in-store” (BOPIS)
+
+## Current challenges in real time inventory
+
+
+
+## Why you should use Redis for local inventory search
+
+- **Accurate location/regional inventory search**: Redis Cloud geospatial search capabilities enable retailers to provide local inventories by store location across geographies and regions based on a consumer's location. This enables a real-time view of store inventory and and seamless BOPIS shopping experience.
+
+- **Consistent and accurate inventory view across multichannel and omnichannel experiences**: Accurate inventory information no matter what channel the shopper is using, in-store, kiosk, online, or mobile. Redis Cloud provides a single source of truth for inventory information across all channels.
+
+- **Real-time search performance at scale**: Redis Cloud real-time search and query engine allows retailers to provide instant application and inventory search responses and scale performance effortlessly during peak periods.
+
+## Real-time local inventory search with Redis
+
+
+
+Redis provides geospatial search capabilities across a group of stores or warehouses in a region or geographic area allowing a retailer to quickly show the available inventory local to the customer.
+
+Redis Cloud processes event streams, keeping store inventories up-to-date in real-time. This enhances the customer experience with localized, accurate search of inventory while fulfilling orders from the nearest and fewest stores possible.
+
+This solution lowers days sales of inventory (DSI), selling inventory faster and carrying less inventory for increased revenue generation and profits over a shorter time period.
+
+It also reduces fulfillment costs to home and local stores enhancing a retailer's ability to fulfill orders with the lowest delivery and shipping costs.
+
+:::tip Customer proof points
+
+
+
+:::
+
+## Building a real time local inventory search with redis
+
+
+
+### Setting up the data
+
+Once the application source code is downloaded, run following commands to populate data in Redis:
+
+```shell
+# install packages
+npm install
+
+# Seed data to Redis
+npm run seed
+```
+
+The demo uses two collections:
+
+- **Product collection**: Stores product details like `productId`, `name`, `price`, `image`, and other details
+ 
+
+:::tip
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to view your Redis data or to play with raw Redis commands in the workbench.
+:::
+
+- **StoresInventory collection**: Stores product quantity available at different local stores.
+
+For demo purpose, we are using the below regions in New York, US as store locations. Products are mapped to these location stores with a `storeId` and `quantity`.
+
+
+
+
+
+Let's build the following APIs to demonstrate geospatial search using Redis:
+
+- **InventorySearch API**: Search Products in local stores within a search radius.
+- **InventorySearchWithDistance API**: Search Product in local stores within search radius and sort results by distance from current user location to store.
+
+### InventorySearch API
+
+
+
+### InventorySearchWithDistance API
+
+
+
+## Ready to use Redis for real-time local inventory search?
+
+Hopefully this tutorial has helped you visualize how to use Redis for real-time local inventory search across different regional stores. For additional resources related to this topic, check out the links below:
+
+### Additional resources
+
+- Real time inventory with Redis
+ - [Available to Promise in Real-time Inventory](/howtos/solutions/real-time-inventory/available-to-promise)
+- General
+
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard-semantic-text.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard-semantic-text.png
new file mode 100644
index 00000000000..658a3c7af9a
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard-semantic-text.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard.png
new file mode 100644
index 00000000000..cbb383335e0
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/01-dashboard.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/02-cart.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/02-cart.png
new file mode 100644
index 00000000000..9f096691ed5
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/02-cart.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/05-order-history.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/05-order-history.png
new file mode 100644
index 00000000000..747560cba9f
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/05-order-history.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/06-admin-charts.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/06-admin-charts.png
new file mode 100644
index 00000000000..4bfa493670a
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/06-admin-charts.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/07-admin-top-trending.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/07-admin-top-trending.png
new file mode 100644
index 00000000000..5b8be9e8222
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/07-admin-top-trending.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/images/08-settings.png b/docs/howtos/solutions/triggers-and-functions/common-tf/images/08-settings.png
new file mode 100644
index 00000000000..ddd70498a6a
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/common-tf/images/08-settings.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-ecommerce-tf.mdx b/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-ecommerce-tf.mdx
new file mode 100644
index 00000000000..08f2343ceda
--- /dev/null
+++ b/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-ecommerce-tf.mdx
@@ -0,0 +1,20 @@
+The e-commerce microservices application consists of a frontend, built using [Next.js](https://nextjs.org/) with [TailwindCSS](https://tailwindcss.com/). The application backend uses [Node.js](https://nodejs.org). The data is stored in [Redis](https://redis.com/try-free/) and either MongoDB or PostgreSQL, using [Prisma](https://www.prisma.io/docs/reference/database-reference/supported-databases). Below are screenshots showcasing the frontend of the e-commerce app.
+
+**Dashboard:** Displays a list of products with different search functionalities, configurable in the settings page.
+
+
+**Settings:** Accessible by clicking the gear icon at the top right of the dashboard. Control the search bar, chatbot visibility, and other features here.
+
+
+**Dashboard (Semantic Text Search):** Configured for semantic text search, the search bar enables natural language queries. Example: "pure cotton blue shirts."
+
+
+**Shopping Cart:** Add products to the cart and check out using the "Buy Now" button.
+
+
+**Order History:** Post-purchase, the 'Orders' link in the top navigation bar shows the order status and history.
+
+
+**Admin Panel:** Accessible via the 'admin' link in the top navigation. Displays purchase statistics and trending products.
+
+
diff --git a/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-source-code-tf.mdx b/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-source-code-tf.mdx
new file mode 100644
index 00000000000..7aa733bf44c
--- /dev/null
+++ b/docs/howtos/solutions/triggers-and-functions/common-tf/microservices-source-code-tf.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone --branch v9.2.0 https://github.com/redis-developer/redis-microservices-ecommerce-solutions
+
+:::
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/add-triggers-redis-insight.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/add-triggers-redis-insight.png
new file mode 100644
index 00000000000..604142753bc
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/add-triggers-redis-insight.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/how-triggers-work.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/how-triggers-work.png
new file mode 100644
index 00000000000..6b45a83022f
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/how-triggers-work.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-test-ri.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-test-ri.png
new file mode 100644
index 00000000000..8c19f3c633b
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-test-ri.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-verify-ri.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-verify-ri.png
new file mode 100644
index 00000000000..18452cd64bc
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/key-space-trigger-verify-ri.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-test-ri.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-test-ri.png
new file mode 100644
index 00000000000..21e5276126a
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-test-ri.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-verify-ri.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-verify-ri.png
new file mode 100644
index 00000000000..307ecaf6630
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/on-demand-trigger-verify-ri.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-test-ri.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-test-ri.png
new file mode 100644
index 00000000000..86f6d5b2d37
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-test-ri.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-charts.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-charts.png
new file mode 100644
index 00000000000..368c564ff4f
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-charts.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-top-trending.png b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-top-trending.png
new file mode 100644
index 00000000000..441124b66f0
Binary files /dev/null and b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/images/stream-trigger-verify-admin-top-trending.png differ
diff --git a/docs/howtos/solutions/triggers-and-functions/getting-started-tf/index-triggers-and-functions.mdx b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/index-triggers-and-functions.mdx
new file mode 100644
index 00000000000..87fc28fb9d0
--- /dev/null
+++ b/docs/howtos/solutions/triggers-and-functions/getting-started-tf/index-triggers-and-functions.mdx
@@ -0,0 +1,633 @@
+---
+id: index-triggers-and-functions
+title: Getting Started With Triggers and Functions in Redis
+sidebar_label: Getting Started With Triggers and Functions in Redis
+slug: /howtos/solutions/triggers-and-functions/getting-started
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import InitialMicroservicesArchitecture from '../../microservices/common-data/microservices-arch.mdx';
+import MicroservicesEcommerceTFDesign from '../common-tf/microservices-ecommerce-tf.mdx';
+import SourceCode from '../common-tf/microservices-source-code-tf.mdx';
+
+
+
+## What you will learn in this tutorial
+
+In this comprehensive tutorial on Redis 7.2's **Triggers and Functions**, you'll gain insights and practical skills in the following areas:
+
+- **Understanding Redis Triggers and Functions**: Grasp the fundamentals of Redis's new programmability features, including how to use JavaScript code for data-driven triggers and functions.
+- **Application Scenarios**: Explore real-world applications in an e-commerce context, such as inventory management and sales statistics calculations.
+- **Types of Triggers**: Learn the distinction and use cases for `On-demand` Triggers, `KeySpace` Triggers, and `Stream` Triggers.
+- **Hands-on Implementation**: Get practical experience by creating and deploying various triggers and functions in a simulated e-commerce environment.
+
+## Microservices architecture for an e-commerce application
+
+
+
+
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+## What are triggers and functions ?
+
+Triggers and functions represent a revolutionary step in Redis's programmability, introduced in Redis 7.2. This feature empowers developers to program, store, and execute **JavaScript code** in response to data changes directly within the Redis database, similar to stored procedures or triggers in traditional SQL databases.
+
+This capability lets developers define events (called `triggers`) to execute `functions` closer to the data. That is, developers define business logic that executes in response to database events or commands. That speeds up the code and related interactions, because there is no wait to bring code from clients into the database.
+
+
+
+### Advantages
+
+Incorporating triggers and functions into Redis capitalizes on its renowned real-time performance and simplicity:
+
+- **Reduced Latency**: By processing tasks directly within Redis, you minimize network overhead, saving time and computational resources.
+- **Real-time event processing**: Triggers are executed in **real-time** and keep the **atomicity** of the command. This removes potential data inconsistencies that are introduced by applying async logic through application code.
+- **JavaScript**: Use the most known language by professional developers. This lowers the learning curve compared to the lesser-known Lua Functions in earlier Redis Gears.
+- **Compatibility**: Seamlessly integrate with existing Redis Stack capabilities and data structures.
+
+### Types of triggers and functions
+
+Triggers and functions in Redis can be categorized into three types, based on their activation methods:
+
+- **On-demand Triggers**: These are explicitly invoked by calling them directly.
+- **KeySpace Triggers**: Triggered by operations on keys, such as creation, update, or deletion.
+- **Stream Triggers**: Activated when new entries are added to a Redis stream.
+
+### Sample product data
+
+To illustrate the application of triggers and functions, let's consider a simplified e-commerce dataset. This dataset includes detailed product information, which we will use throughout our tutorial.
+
+```ts title="database/fashion-dataset/001/products/*.json"
+const products = [
+ {
+ productId: '11000',
+ price: 3995,
+ productDisplayName: 'Puma Men Slick 3HD Yellow Black Watches',
+ variantName: 'Slick 3HD Yellow',
+ brandName: 'Puma',
+ ageGroup: 'Adults-Men',
+ gender: 'Men',
+ displayCategories: 'Accessories',
+ masterCategory_typeName: 'Accessories',
+ subCategory_typeName: 'Watches',
+ styleImages_default_imageURL:
+ 'http://host.docker.internal:8080/images/11000.jpg',
+ productDescriptors_description_value: 'Stylish and comfortable, ...',
+ stockQty: 25,
+ },
+ //...
+];
+```
+
+## OnDemand trigger
+
+On-demand triggers in Redis are JavaScript functions that are explicitly invoked to perform specific tasks.
+
+### Application Scenario: Resetting Inventory
+
+In our e-commerce demo, consider a feature where we need to reset the stock quantity of all products. We'll implement this by clicking a `RESET STOCK QTY` button in the UI dashboard, triggering the `resetInventory` function.
+
+### Creating the function
+
+Let's craft a function named `resetInventory` under the namespace `OnDemandTriggers`. This function will reset the inventory (stock quantity) of all products to 25.
+
+```js title="database/src/triggers/on-demand-trigger.js"
+#!js name=OnDemandTriggers api_version=1.0
+
+redis.registerAsyncFunction('resetInventory', async function (client) {
+ let cursor = '0';
+ const DEFAULT_PRODUCT_QTY = 25;
+
+ redis.log('resetInventory');
+ do {
+ client.block((client) => {
+ //scan all the product keys in the database
+ let res = client.call('scan', cursor, 'match', 'products:productId:*');
+ cursor = res[0];
+ let keys = res[1];
+ // loop through all the product keys and set the stockQty to 25
+ keys.forEach((key) => {
+ if (!key.match('index:hash')) {
+ client.call(
+ 'JSON.SET',
+ key,
+ '$.stockQty',
+ DEFAULT_PRODUCT_QTY.toString(),
+ );
+ }
+ });
+ });
+ } while (cursor != '0');
+
+ return 'resetInventory completed !';
+});
+```
+
+### Adding the function to Redis
+
+We can add functions to Redis using various methods:
+
+1. Using redis-cli
+
+```sh
+redis-cli -x TFUNCTION LOAD < ./on-demand-trigger.js
+# or if you want to replace the function
+redis-cli -x TFUNCTION LOAD REPLACE . < ./on-demand-trigger.js
+```
+
+2. Using code
+
+```ts title="database/src/triggers.ts"
+import type { NodeRedisClientType } from './config.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+
+async function addTriggerToRedis(
+ fileRelativePath: string,
+ redisClient: NodeRedisClientType,
+) {
+ const filePath = path.join(__dirname, fileRelativePath);
+ const fileData = await fs.readFile(filePath);
+ let jsCode = fileData.toString();
+ jsCode = jsCode.replace(/\r?\n/g, '\n');
+
+ try {
+ const result = await redisClient.sendCommand([
+ 'TFUNCTION',
+ 'LOAD',
+ 'REPLACE',
+ jsCode,
+ ]);
+ console.log(`addTriggersToRedis ${fileRelativePath}`, result);
+ } catch (err) {
+ console.log(err);
+ }
+}
+```
+
+```ts
+addTriggerToRedis('triggers/on-demand-trigger.js', redisClient);
+```
+
+3. Using RedisInsight
+
+Navigate to the `Triggers and Functions` section in RedisInsight, then to `Libraries`, and use create library to paste and save your function.
+
+
+
+### Testing the function
+
+1. Using redis-cli
+
+```sh
+redis-cli TFCALLASYNC OnDemandTriggers.resetInventory 0
+```
+
+2. Using code
+
+Clicking on the 'RESET STOCK QTY' button triggers the triggerResetInventory API.
+
+```json
+POST http://localhost:3000/products/triggerResetInventory
+{
+}
+```
+
+This invokes the `resetInventory` function:
+
+```ts title="server/src/services/products/src/service-impl.ts"
+const triggerResetInventory = async () => {
+ const redisClient = getNodeRedisClient();
+
+ //@ts-ignore
+ const result = await redisClient.sendCommand(
+ ['TFCALLASYNC', 'OnDemandTriggers.resetInventory', '0'],
+ {
+ isolated: true,
+ },
+ );
+ console.log(`triggerResetInventory : `, result);
+
+ return result;
+};
+```
+
+3. Using RedisInsight
+
+Test the command in RedisInsight's workbench and view the results.
+
+
+
+### Verifying data integrity
+
+Post-execution, check whether the `stockQty` for each product is reset to the default value.
+
+
+
+## KeySpace trigger
+
+A KeySpace trigger allows you to execute custom logic whenever a set of keys matching a specific pattern is added/ modified in the Redis database. It provides a way to react to changes in the data and perform actions based on those changes.
+
+### Application Scenario : Managing product stock quantity
+
+In our e-commerce demo, let's address a common need: decreasing product stock quantity upon placing an order. We'll achieve this using a `KeySpace trigger` that listens to `orders:orderId` keys and updates the product stock quantities accordingly.
+
+### Creating the function
+
+We'll develop `updateProductStockQty` under the `KeySpaceTriggers` namespace. This function will be responsible for adjusting stock quantities based on order details.
+
+```js title="database/src/triggers/key-space-trigger.js"
+#!js name=KeySpaceTriggers api_version=1.0
+redis.registerKeySpaceTrigger(
+ 'updateProductStockQty',
+ 'orders:orderId:', // Keys starting with this prefix are monitored
+ function (client, data) {
+ const errors = [];
+
+ try {
+ if (
+ client &&
+ data?.event == 'json.set' &&
+ data?.key != 'orders:orderId:index:hash'
+ ) {
+ const orderId = data.key;
+ // get the order details from the orderId key
+ let result = client.call('JSON.GET', orderId);
+ result = result ? JSON.parse(result) : '';
+ const order = Array.isArray(result) ? result[0] : result;
+
+ if (order?.products?.length && !order.triggerProcessed) {
+ try {
+ //create a log stream to log the trigger events and errors
+ client.call(
+ 'XGROUP',
+ 'CREATE',
+ 'TRIGGER_LOGS_STREAM',
+ 'TRIGGER_LOGS_GROUP',
+ '$',
+ 'MKSTREAM',
+ );
+ } catch (streamConErr) {
+ // if log stream already exists
+ }
+
+ // reduce stockQty for each product in the order
+ for (const product of order.products) {
+ let decreaseQtyBy = (-1 * product.qty).toString();
+ client.call(
+ 'JSON.NUMINCRBY',
+ `products:productId:${product.productId}`,
+ '.stockQty',
+ decreaseQtyBy,
+ );
+
+ // add log entry
+ client.call(
+ 'XADD',
+ 'TRIGGER_LOGS_STREAM',
+ '*',
+ 'message',
+ `For productId ${product.productId}, stockQty ${decreaseQtyBy}`,
+ 'orderId',
+ orderId,
+ 'function',
+ 'updateProductStockQty',
+ );
+ }
+
+ // set triggerProcessed flag to avoid duplicate processing
+ client.call('JSON.SET', orderId, '.triggerProcessed', '1');
+ }
+ }
+ } catch (generalErr) {
+ generalErr = JSON.stringify(
+ generalErr,
+ Object.getOwnPropertyNames(generalErr),
+ );
+ errors.push(generalErr);
+ }
+
+ if (errors.length) {
+ //log error
+ client.call(
+ 'XADD',
+ 'TRIGGER_LOGS_STREAM',
+ '*',
+ 'message',
+ JSON.stringify(errors),
+ 'orderId',
+ data.key,
+ 'function',
+ 'updateProductStockQty',
+ );
+ }
+ },
+);
+```
+
+In this script, we listen to changes in the `orders:orderId:` keys. Upon detecting a new order, the function retrieves the order details and accordingly decreases the stock quantity for each product in the order.
+
+### Adding the function to Redis
+
+We can add functions to Redis using various methods:
+
+1. Using redis-cli
+
+```sh
+redis-cli -x TFUNCTION LOAD < ./key-space-trigger.js
+# or if you want to replace the function
+redis-cli -x TFUNCTION LOAD REPLACE . < ./key-space-trigger.js
+```
+
+2. Using code
+
+```ts title="database/src/triggers.ts"
+import type { NodeRedisClientType } from './config.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+
+async function addTriggerToRedis(
+ fileRelativePath: string,
+ redisClient: NodeRedisClientType,
+) {
+ const filePath = path.join(__dirname, fileRelativePath);
+ const fileData = await fs.readFile(filePath);
+ let jsCode = fileData.toString();
+ jsCode = jsCode.replace(/\r?\n/g, '\n');
+
+ try {
+ const result = await redisClient.sendCommand([
+ 'TFUNCTION',
+ 'LOAD',
+ 'REPLACE',
+ jsCode,
+ ]);
+ console.log(`addTriggersToRedis ${fileRelativePath}`, result);
+ } catch (err) {
+ console.log(err);
+ }
+}
+```
+
+```ts
+addTriggerToRedis('triggers/key-space-trigger.js', redisClient);
+```
+
+3. Using RedisInsight
+
+Navigate to the `Triggers and Functions` section in RedisInsight, then to `Libraries`, and use create library to paste and save your function.
+
+
+
+### Testing the function
+
+In our demo, placing an order through the `Buy Now` button triggers the `createOrder` API, which in turn creates a new `orders:orderId:` key, activating the `updateProductStockQty` function.
+
+Sample createOrder API request:
+
+```json
+POST http://localhost:3000/orders/createOrder
+{
+ "products": [
+ {
+ "productId": "11002",
+ "qty": 1,
+ "productPrice": 4950,
+ },
+ {
+ "productId": "11012",
+ "qty": 2,
+ "productPrice": 1195,
+ }
+ ]
+}
+```
+
+A sample order creation command in Redis:
+
+```sh
+"JSON.SET" "orders:orderId:24b38a47-2b7d-4c5d-ba25-b74749e34c65" "$" "{"products":[{"productId":"10381","qty":1,"productPrice":2499,"productData":{}},{"productId":"11030","qty":1,"productPrice":1099,"productData":{}}],"userId":"USR_f0f00a86-7131-40e1-9d89-765b4cc1927f","orderId":"24b38a47-2b7d-4c5d-ba25-b74749e34c65","orderStatusCode":1}"
+```
+
+The creation of this new key triggers `updateProductStockQty`, leading to the adjustment of stock quantities.
+
+Monitor the trigger's activity in the `TRIGGER_LOGS_STREAM` for logs and potential errors.
+
+
+
+### Verifying data integrity
+
+After the function execution, verify the decreased `stockQty` for each involved product.
+
+
+
+## Stream trigger
+
+A stream trigger allows you to listen to a Redis stream and execute a function whenever new data is added to the stream. It is commonly used for real-time data processing and event-driven architectures.
+
+### Application Scenario : Calculating sales statistics
+
+In our e-commerce demo, let's consider a feature where we need to calculate sales statistics for the products. We'll implement this using a `Stream trigger` that listens to `TRANSACTION_STREAM` and updates the sales statistics accordingly.
+
+### Creating the function
+
+We'll develop `calculateStats` under the `StreamTriggers` namespace. This function will be responsible for calculating sales statistics based on the order details.
+
+```js title="database/src/triggers/stream-trigger.js"
+#!js name=StreamTriggers api_version=1.0
+
+redis.registerStreamTrigger(
+ 'calculateStats', // trigger name
+ 'TRANSACTION_STREAM', // Detects new data added to the stream
+ function (client, data) {
+ var streamEntry = {};
+ for (let i = 0; i < data.record?.length; i++) {
+ streamEntry[data.record[i][0]] = data.record[i][1];
+ }
+
+ streamEntry.transactionPipeline = JSON.parse(
+ streamEntry.transactionPipeline,
+ );
+ streamEntry.orderDetails = JSON.parse(streamEntry.orderDetails);
+
+ if (
+ streamEntry.transactionPipeline?.length == 1 &&
+ streamEntry.transactionPipeline[0] == 'PAYMENT_PROCESSED' &&
+ streamEntry.orderDetails
+ ) {
+ //log
+ client.call(
+ 'XADD',
+ 'TRIGGER_LOGS_STREAM',
+ '*',
+ 'message',
+ `${streamEntry.transactionPipeline}`,
+ 'orderId',
+ `orders:orderId:${streamEntry.orderDetails.orderId}`,
+ 'function',
+ 'calculateStats',
+ );
+
+ const orderAmount = parseInt(streamEntry.orderDetails.orderAmount); //remove decimal
+ const products = streamEntry.orderDetails.products;
+
+ // sales
+ client.call('INCRBY', 'statsTotalPurchaseAmount', orderAmount.toString());
+
+ for (let product of products) {
+ const totalProductAmount =
+ parseInt(product.qty) * parseInt(product.productPrice);
+
+ // trending products
+ client.call(
+ 'ZINCRBY',
+ 'statsProductPurchaseQtySet',
+ product.qty.toString(),
+ product.productId,
+ );
+
+ // category wise purchase interest
+ const category = (
+ product.productData.masterCategory_typeName +
+ ':' +
+ product.productData.subCategory_typeName
+ ).toLowerCase();
+ client.call(
+ 'ZINCRBY',
+ 'statsCategoryPurchaseAmountSet',
+ totalProductAmount.toString(),
+ category,
+ );
+
+ // largest brand purchases
+ const brand = product.productData.brandName;
+ client.call(
+ 'ZINCRBY',
+ 'statsBrandPurchaseAmountSet',
+ totalProductAmount.toString(),
+ brand,
+ );
+ }
+ }
+ },
+ {
+ isStreamTrimmed: false, //whether the stream should be trimmed automatically after the data is processed by the consumer.
+ window: 1,
+ },
+);
+```
+
+In above `calculateStats` function, we are listening to `TRANSACTION_STREAM` and updating different sales statistics like
+
+- `statsTotalPurchaseAmount` variable stores total purchase amount
+- `statsProductPurchaseQtySet` is a sorted set which tracks trending products based on highest purchase quantity
+- `statsCategoryPurchaseAmountSet` is a sorted set which tracks category wise purchase interest
+- `statsBrandPurchaseAmountSet` is a sorted set which tracks largest brand purchases
+
+### Adding the function to Redis
+
+We can add functions to Redis using various methods:
+
+1. Using redis-cli
+
+```sh
+redis-cli -x TFUNCTION LOAD < ./stream-trigger.js
+# or if you want to replace the function
+redis-cli -x TFUNCTION LOAD REPLACE . < ./stream-trigger.js
+```
+
+2. Using code
+
+```ts title="database/src/triggers.ts"
+import type { NodeRedisClientType } from './config.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+
+async function addTriggerToRedis(
+ fileRelativePath: string,
+ redisClient: NodeRedisClientType,
+) {
+ const filePath = path.join(__dirname, fileRelativePath);
+ const fileData = await fs.readFile(filePath);
+ let jsCode = fileData.toString();
+ jsCode = jsCode.replace(/\r?\n/g, '\n');
+
+ try {
+ const result = await redisClient.sendCommand([
+ 'TFUNCTION',
+ 'LOAD',
+ 'REPLACE',
+ jsCode,
+ ]);
+ console.log(`addTriggersToRedis ${fileRelativePath}`, result);
+ } catch (err) {
+ console.log(err);
+ }
+}
+```
+
+```ts
+addTriggerToRedis('triggers/stream-trigger.js', redisClient);
+```
+
+3. Using RedisInsight
+
+Navigate to the `Triggers and Functions` section in RedisInsight, then to `Libraries`, and use create library to paste and save your function.
+
+
+
+### Testing the function
+
+In our demo, placing an order through the `Buy Now` button creates a new order involving different transaction steps like transaction risk assessment, payment fulfillment etc. All these steps along with order details are logged in `TRANSACTION_STREAM`.
+
+Sample code to add details to a stream:
+
+```ts
+const addMessageToTransactionStream = async (message) => {
+ if (message) {
+ const streamKeyName = 'TRANSACTION_STREAM';
+ try {
+ const nodeRedisClient = getNodeRedisClient();
+ if (nodeRedisClient && message) {
+ const id = '*'; //* = auto generate
+ await nodeRedisClient.xAdd(streamKeyName, id, message);
+ }
+ } catch (err) {
+ console.error('addMessageToTransactionStream error !', err);
+ }
+ }
+};
+```
+
+A sample command to add details to the stream:
+
+```sh
+"XADD" "TRANSACTION_STREAM" "*" "action" "PAYMENT_PROCESSED" "userId" "USR_f0f00a86-7131" "orderDetails" "{'orderId':'bc438c5d-117e-41bd-97fa-943c03be0b1c','products':[],'paymentId':'clrrl8yp50007pf851m7f92u2'}" "transactionPipeline" "['PAYMENT_PROCESSED']"
+```
+
+The `calculateStats` function listens to `TRANSACTION_STREAM` stream for `PAYMENT_PROCESSED` action and updates the sales statistics accordingly.
+
+Check different stats variable values in RedisInsight which were used in trigger function `calculateStats`.
+
+
+### Verifying data integrity
+
+After the function execution, verify the updated admin dashboard.
+
+**Admin Panel:** Accessible via the 'admin' link in the top navigation. Check purchase statistics and trending products in UI.
+
+
+
+## Ready to use Redis triggers and functions
+
+We've covered key concepts like `On-demand`, `KeySpace`, and `Stream` triggers, and applied them in real e-commerce scenarios. These advanced functionalities of Redis open up a myriad of possibilities for data processing and automation, allowing you to build applications that are not only faster but also more intelligent.
+
+As you continue to explore Redis and its evolving ecosystem, remember that these `triggers and functions` are just the beginning. Redis offers a rich set of features that can be combined in creative ways to solve complex problems and deliver high-performance solutions.
+
+### References
+
+- [Triggers and Functions quick start](https://redis.io/docs/interact/programmability/triggers-and-functions/quick_start_ri/)
diff --git a/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-image.png b/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-image.png
new file mode 100644
index 00000000000..82907b0fd46
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-image.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-text.png b/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-text.png
new file mode 100644
index 00000000000..6e0bc20e139
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/01-dashboard-semantic-text.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/01-dashboard.png b/docs/howtos/solutions/vector/common-ai/images/01-dashboard.png
new file mode 100644
index 00000000000..46ea83abb61
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/01-dashboard.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/02-ai-bot.png b/docs/howtos/solutions/vector/common-ai/images/02-ai-bot.png
new file mode 100644
index 00000000000..d5fb913aa01
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/02-ai-bot.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/03-ai-bot-product.png b/docs/howtos/solutions/vector/common-ai/images/03-ai-bot-product.png
new file mode 100644
index 00000000000..0cccb7bc23a
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/03-ai-bot-product.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/04-ai-product-shopping-cart.png b/docs/howtos/solutions/vector/common-ai/images/04-ai-product-shopping-cart.png
new file mode 100644
index 00000000000..8bd09fd547e
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/04-ai-product-shopping-cart.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/05-order-history.png b/docs/howtos/solutions/vector/common-ai/images/05-order-history.png
new file mode 100644
index 00000000000..4c0d7059449
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/05-order-history.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/06-admin-charts.png b/docs/howtos/solutions/vector/common-ai/images/06-admin-charts.png
new file mode 100644
index 00000000000..4bfa493670a
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/06-admin-charts.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/07-admin-top-trending.png b/docs/howtos/solutions/vector/common-ai/images/07-admin-top-trending.png
new file mode 100644
index 00000000000..4f73d08869d
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/07-admin-top-trending.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/08-settings-ai.png b/docs/howtos/solutions/vector/common-ai/images/08-settings-ai.png
new file mode 100644
index 00000000000..56a4496f09e
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/08-settings-ai.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/images/08-settings-image-summary.png b/docs/howtos/solutions/vector/common-ai/images/08-settings-image-summary.png
new file mode 100644
index 00000000000..56a4496f09e
Binary files /dev/null and b/docs/howtos/solutions/vector/common-ai/images/08-settings-image-summary.png differ
diff --git a/docs/howtos/solutions/vector/common-ai/microservices-ecommerce-ai.mdx b/docs/howtos/solutions/vector/common-ai/microservices-ecommerce-ai.mdx
new file mode 100644
index 00000000000..5f316f38ec7
--- /dev/null
+++ b/docs/howtos/solutions/vector/common-ai/microservices-ecommerce-ai.mdx
@@ -0,0 +1,29 @@
+The e-commerce microservices application consists of a frontend, built using [Next.js](https://nextjs.org/) with [TailwindCSS](https://tailwindcss.com/). The application backend uses [Node.js](https://nodejs.org). The data is stored in [Redis](https://redis.com/try-free/) and either MongoDB or PostgreSQL, using [Prisma](https://www.prisma.io/docs/reference/database-reference/supported-databases). Below are screenshots showcasing the frontend of the e-commerce app.
+
+**Dashboard:** Displays a list of products with different search functionalities, configurable in the settings page.
+
+
+**Settings:** Accessible by clicking the gear icon at the top right of the dashboard. Control the search bar, chatbot visibility, and other features here.
+
+
+**Dashboard (Semantic Text Search):** Configured for semantic text search, the search bar enables natural language queries. Example: "pure cotton blue shirts."
+
+
+**Dashboard (Semantic Image-Based Queries):** Configured for semantic image summary search, the search bar allows for image-based queries. Example: "Left chest nike logo."
+
+
+**Chat Bot:** Located at the bottom right corner of the page, assisting in product searches and detailed views.
+
+
+Selecting a product in the chat displays its details on the dashboard.
+
+
+**Shopping Cart:** Add products to the cart and check out using the "Buy Now" button.
+
+
+**Order History:** Post-purchase, the 'Orders' link in the top navigation bar shows the order status and history.
+
+
+**Admin Panel:** Accessible via the 'admin' link in the top navigation. Displays purchase statistics and trending products.
+
+
diff --git a/docs/howtos/solutions/vector/common-ai/microservices-source-code-ai.mdx b/docs/howtos/solutions/vector/common-ai/microservices-source-code-ai.mdx
new file mode 100644
index 00000000000..7aa733bf44c
--- /dev/null
+++ b/docs/howtos/solutions/vector/common-ai/microservices-source-code-ai.mdx
@@ -0,0 +1,7 @@
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+git clone --branch v9.2.0 https://github.com/redis-developer/redis-microservices-ecommerce-solutions
+
+:::
diff --git a/docs/howtos/solutions/vector/gen-ai-chatbot/images/chat-bot-flow.png b/docs/howtos/solutions/vector/gen-ai-chatbot/images/chat-bot-flow.png
new file mode 100644
index 00000000000..8e4e67ac59a
Binary files /dev/null and b/docs/howtos/solutions/vector/gen-ai-chatbot/images/chat-bot-flow.png differ
diff --git a/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-ai-products.png b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-ai-products.png
new file mode 100644
index 00000000000..2607f2a3927
Binary files /dev/null and b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-ai-products.png differ
diff --git a/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-history.png b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-history.png
new file mode 100644
index 00000000000..32fc0f8a65d
Binary files /dev/null and b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-history.png differ
diff --git a/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-log.png b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-log.png
new file mode 100644
index 00000000000..ee2c3318216
Binary files /dev/null and b/docs/howtos/solutions/vector/gen-ai-chatbot/images/redis-insight-chat-log.png differ
diff --git a/docs/howtos/solutions/vector/gen-ai-chatbot/index-gen-ai-chatbot.mdx b/docs/howtos/solutions/vector/gen-ai-chatbot/index-gen-ai-chatbot.mdx
new file mode 100644
index 00000000000..ee9ff9d32f9
--- /dev/null
+++ b/docs/howtos/solutions/vector/gen-ai-chatbot/index-gen-ai-chatbot.mdx
@@ -0,0 +1,547 @@
+---
+id: index-solutions-gen-ai-chatbot
+title: How to Build a GenAI Chatbot Using LangChain and Redis
+sidebar_label: How to Build a GenAI Chatbot Using LangChain and Redis
+slug: /howtos/solutions/vector/gen-ai-chatbot
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import InitialMicroservicesArchitecture from '../../microservices/common-data/microservices-arch.mdx';
+import MicroservicesEcommerceAIDesign from '../common-ai/microservices-ecommerce-ai.mdx';
+import SourceCode from '../common-ai/microservices-source-code-ai.mdx';
+
+
+
+## What you will learn in this tutorial
+
+In this tutorial, you'll learn how to build a GenAI chatbot using `LangChain` and `Redis`. You'll also learn how to use `OpenAI's` language model to generate responses to user queries and how to use Redis to store and retrieve data.
+
+Here's what's covered:
+
+- **E-Commerce App** : A sample e-commerce application where users can search for products and ask questions about them, add them to their cart, and purchase them.
+- **Chatbot Architecture** : The architecture of the chatbot, including the flow diagram, sample user prompt and it's AI response.
+- **Database setup** : Generating OpenAI embeddings for products and storing them in Redis.
+- **Setting up the chatbot API** : Creating a chatbot API that uses OpenAI and Redis to answer user questions and recommend products.
+
+## Terminology
+
+**Generative AI**, also known as **GenAI**, is a category of artificial intelligence that specializes in creating new content based on pre-existing data. It can generate a wide array of content types, including text, images, videos, sounds, code, 3D designs, and other media formats. Unlike traditional AI models that focus on analyzing and interpreting existing data, GenAI models learn from existing data and then use their knowledge to generate something entirely new.
+
+**[LangChain](https://js.langchain.com)** is an innovative library for building language model applications. It offers a structured way to combine different components like language models (e.g., OpenAI's models), storage solutions (like Redis), and custom logic. This modular approach facilitates the creation of sophisticated AI applications, including chatbots.
+
+**[OpenAI](https://openai.com/)** provides advanced language models like GPT-3, which have revolutionized the field with their ability to understand and generate human-like text. These models form the backbone of many modern AI applications, including chatbots.
+
+## Microservices architecture for an e-commerce application
+
+
+
+
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+## Chatbot architecture
+
+### Flow diagram
+
+
+
+1> **Create Standalone Question**: Create a standalone question using `OpenAI's` language model.
+
+A standalone question is just a question reduced to the minimum number of words needed to express the request for information.
+
+```js
+//Example
+userQuestion =
+ "I'm thinking of buying one of your T-shirts but I need to know what your returns policy is as some T-shirts just don't fit me and I don't want to waste money.";
+
+//semanticMeaning of above question
+standAloneQuestion = 'What is your return policy?';
+```
+
+2> **Create Embeddings for Question**: Once the question is created, `OpenAI's` language model generates an embedding for the question.
+
+3> **Find Nearest Match in Redis Vector Store**: The embedding is then used to query `Redis` vector store. The system searches for the nearest match to the question embedding among stored vectors
+
+4> **Get Answer**: With the user initial question, the nearest match from the vector store, and the conversation memory, `OpenAI's` language model generates an answer. This answer is then provided to the user.
+
+Note : The system maintains a conversation memory, which tracks the ongoing conversation's context. This memory is crucial for ensuring the continuity and relevance of the conversation.
+
+5> **User Receives Answer**: The answer is sent back to the user, completing the interaction cycle. The conversation memory is updated with this latest exchange to inform future responses.
+
+### Sample user prompt and AI response
+
+Say, OriginalQuestion of user is as follows:
+
+`I am looking for a watch, Can you recommend anything for formal occasions with price under 50 dollars?`
+
+Converted standaloneQuestion by openAI is as follows:
+
+`What watches do you recommend for formal occasions with a price under $50?`
+
+After vector similarity search on **Redis**, we get the following similarProducts:
+
+```ts
+similarProducts = [
+ {
+ pageContent: ` Product details are as follows:
+ productId: 11005.
+ productDisplayName: Puma Men Visor 3HD Black Watch.
+ price: 5495 ...`,
+ metadata: { productId: '11005' },
+ },
+ {
+ pageContent: ` Product details are as follows:
+ productId: 11006.
+ productDisplayName: Puma Men Race Luminous Black Chronograph Watch.
+ price: 7795 ... `,
+ metadata: { productId: '11006' },
+ },
+];
+```
+
+The final openAI response with above context and earlier chat history (if any) is as follows:
+
+```ts
+answer = `I recommend two watches for formal occasions with a price under $50.
+
+First, we have the Puma Men Visor 3HD Black Watch priced at $54.95. This watch features a heavy-duty design with a stylish dial and chunky casing, giving it a tough appearance - perfect for navigating the urban jungle. It has a square dial shape and a 32 mm case diameter. The watch comes with a 2-year warranty and is water-resistant up to 50 meters.
+
+Second, we have the Puma Men Race Luminous Black Chronograph Watch priced at $77.95. This watch also features a heavy-duty design with a stylish dial and chunky casing. It has a round dial shape and a 40 mm case diameter. The watch comes with a 2-year warranty and is water-resistant up to 50 meters.
+
+Both these watches from Puma are perfect for formal occasions and are priced under $50. I hope this helps, and please let me know if you have any other questions!`;
+```
+
+## Database setup
+
+:::info
+Sign up for an [OpenAI account](https://platform.openai.com/) to get your API key to be used in the demo (add OPEN_AI_API_KEY variable in .env file). You can also refer to the [OpenAI API documentation](https://platform.openai.com/docs/api-reference/introduction) for more information.
+:::
+
+
+
+### Sample data
+
+For the purposes of this tutorial, let's consider a simplified e-commerce context. The `products` JSON provided offers a glimpse into AI search functionalities we'll be operating on.
+
+```ts title="database/fashion-dataset/001/products/*.json"
+const products = [
+ {
+ productId: '11000',
+ price: 3995,
+ productDisplayName: 'Puma Men Slick 3HD Yellow Black Watches',
+ variantName: 'Slick 3HD Yellow',
+ brandName: 'Puma',
+ ageGroup: 'Adults-Men',
+ gender: 'Men',
+ displayCategories: 'Accessories',
+ masterCategory_typeName: 'Accessories',
+ subCategory_typeName: 'Watches',
+ styleImages_default_imageURL:
+ 'http://host.docker.internal:8080/images/11000.jpg',
+ productDescriptors_description_value:
+ 'Stylish and comfortable, ...',
+ stockQty: 25,
+ },
+ //...
+];
+```
+
+### OpenAI embeddings seeding
+
+Below is the sample code to seed `products` data as openAI embeddings into Redis.
+
+```ts title="database/src/open-ai.ts"
+import { Document } from 'langchain/document';
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
+import { RedisVectorStore } from 'langchain/vectorstores/redis';
+
+/**
+ * Adds OpenAI embeddings to Redis for the given products.
+ *
+ * @param _products - An array of (ecommerce) products.
+ * @param _redisClient - The Redis client used to connect to the Redis server.
+ * @param _openAIApiKey - The API key for accessing the OpenAI service.
+ */
+const addOpenAIEmbeddingsToRedis = async (
+ _products,
+ _redisClient,
+ _openAIApiKey,
+) => {
+ if (_products?.length > 0 && _redisClient && _openAIApiKey) {
+ // Check if the data is already seeded
+ const existingKeys = await _redisClient.keys('openAIProducts:*');
+ if (existingKeys.length > 0) {
+ console.log('seeding openAIEmbeddings skipped !');
+ return;
+ }
+
+ const vectorDocs: Document[] = [];
+ // Create a document for each product
+ for (let product of _products) {
+ let doc = new Document({
+ metadata: {
+ productId: product.productId,
+ },
+ pageContent: ` Product details are as follows:
+ productId: ${product.productId}.
+
+ productDisplayName: ${product.productDisplayName}.
+
+ price: ${product.price}.
+
+ variantName: ${product.variantName}.
+
+ brandName: ${product.brandName}.
+
+ ageGroup: ${product.ageGroup}.
+
+ gender: ${product.gender}.
+
+ productColors: ${product.productColors}
+
+ Category: ${product.displayCategories}, ${product.masterCategory_typeName} - ${product.subCategory_typeName}
+
+ productDescription: ${product.productDescriptors_description_value}`,
+ });
+
+ vectorDocs.push(doc);
+ }
+
+ // Create a new OpenAIEmbeddings instance
+ const embeddings = new OpenAIEmbeddings({
+ openAIApiKey: _openAIApiKey,
+ });
+ // Add the documents to the RedisVectorStore
+ const vectorStore = await RedisVectorStore.fromDocuments(
+ vectorDocs,
+ embeddings,
+ {
+ redisClient: _redisClient,
+ indexName: 'openAIProductsIdx',
+ keyPrefix: 'openAIProducts:',
+ },
+ );
+ console.log('seeding OpenAIEmbeddings completed');
+ }
+};
+```
+
+You can observe openAIProducts JSON in RedisInsight:
+
+
+
+:::tip
+
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to visually explore your Redis data or to engage with raw Redis commands in the workbench.
+
+:::
+
+## Setting up the chatbot API
+
+Once products data is seeded as openAI embeddings into Redis, we can create a `chatbot` API to answer user questions and recommend products.
+
+### API end point
+
+The code that follows shows an example API request and response for the `chatBot` API:
+
+**Request**
+
+```json
+POST http://localhost:3000/products/chatBot
+{
+ "userMessage":"I am looking for a watch, Can you recommend anything for formal occasions with price under 50 dollars?"
+}
+```
+
+**Response**
+
+```json
+{
+ "data": "I recommend two watches for formal occasions with a price under $50.
+
+ First, we have the Puma Men Visor 3HD Black Watch priced at $54.95. This watch features a heavy-duty design with a stylish dial and chunky casing, giving it a tough appearance - perfect for navigating the urban jungle. It has a square dial shape and a 32 mm case diameter. The watch comes with a 2-year warranty and is water-resistant up to 50 meters.
+
+ Second, we have the Puma Men Race Luminous Black Chronograph Watch priced at $77.95. This watch also features a heavy-duty design with a stylish dial and chunky casing. It has a round dial shape and a 40 mm case diameter. The watch comes with a 2-year warranty and is water-resistant up to 50 meters.
+
+ Both these watches from Puma are perfect for formal occasions and are priced under $50. I hope this helps, and please let me know if you have any other questions!",
+
+ "error": null,
+ "auth": "SES_54f211db-50a7-45df-8067-c3dc4272beb2"
+}
+```
+
+### API implementation
+
+When you make a request, it goes through the API gateway to the `products` service. Ultimately, it ends up calling an `chatBotMessage` function which looks as follows:
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+import {
+ ChatOpenAI,
+ ChatOpenAICallOptions,
+} from 'langchain/chat_models/openai';
+import { PromptTemplate } from 'langchain/prompts';
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
+import { RedisVectorStore } from 'langchain/vectorstores/redis';
+import { StringOutputParser } from 'langchain/schema/output_parser';
+import { Document } from 'langchain/document';
+
+let llm: ChatOpenAI;
+
+const chatBotMessage = async (
+ _userMessage: string,
+ _sessionId: string,
+ _openAIApiKey: string,
+) => {
+ const CHAT_BOT_LOG = 'CHAT_BOT_LOG_STREAM';
+ const redisWrapperInst = getRedis();
+
+ // Add user message to chat history
+ const chatHistoryName = 'chatHistory:' + _sessionId;
+ redisWrapperInst.addItemToList(
+ chatHistoryName,
+ 'userMessage: ' + _userMessage,
+ );
+ // add log
+ addMessageToStream(
+ { name: 'originalQuestion', comments: _userMessage },
+ CHAT_BOT_LOG,
+ );
+
+ // (1) Create a standalone question
+ const standaloneQuestion = await convertToStandAloneQuestion(
+ _userMessage,
+ _sessionId,
+ _openAIApiKey,
+ );
+ // add log
+ addMessageToStream(
+ { name: 'standaloneQuestion', comments: standaloneQuestion },
+ CHAT_BOT_LOG,
+ );
+
+ // (2) Get similar products from Redis
+ const similarProducts = await getSimilarProductsByVSS(
+ standaloneQuestion,
+ _openAIApiKey,
+ );
+ if (similarProducts?.length) {
+ // add log
+ addMessageToStream(
+ { name: 'similarProducts', comments: JSON.stringify(similarProducts) },
+ CHAT_BOT_LOG,
+ );
+ }
+
+ // Combine the product details into a single document
+ const productDetails = combineVectorDocuments(similarProducts);
+ console.log('productDetails:', productDetails);
+
+ // (3) Get answer from OpenAI
+ const answer = await convertToAnswer(
+ _userMessage,
+ standaloneQuestion,
+ productDetails,
+ _sessionId,
+ _openAIApiKey,
+ );
+ // add log
+ addMessageToStream({ name: 'answer', comments: answer }, CHAT_BOT_LOG);
+
+ // Add answer to chat history
+ redisWrapperInst.addItemToList(
+ chatHistoryName,
+ 'openAIMessage(You): ' + answer,
+ );
+
+ return answer;
+};
+```
+
+Below function converts the userMessage to standaloneQuestion using `openAI`
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+// (1) Create a standalone question
+const convertToStandAloneQuestion = async (
+ _userQuestion: string,
+ _sessionId: string,
+ _openAIApiKey: string,
+) => {
+ const llm = getOpenAIInstance(_openAIApiKey);
+
+ const chatHistory = await getChatHistory(_sessionId);
+
+ const standaloneQuestionTemplate = `Given some conversation history (if any) and a question, convert it to a standalone question.
+ ***********************************************************
+ conversation history:
+ ${chatHistory}
+ ***********************************************************
+ question: {question}
+ standalone question:`;
+
+ const standaloneQuestionPrompt = PromptTemplate.fromTemplate(
+ standaloneQuestionTemplate,
+ );
+
+ const chain = standaloneQuestionPrompt
+ .pipe(llm)
+ .pipe(new StringOutputParser());
+
+ const response = await chain.invoke({
+ question: _userQuestion,
+ });
+
+ return response;
+};
+const getOpenAIInstance = (_openAIApiKey: string) => {
+ if (!llm) {
+ llm = new ChatOpenAI({
+ openAIApiKey: _openAIApiKey,
+ });
+ }
+ return llm;
+};
+
+const getChatHistory = async (_sessionId: string, _separator?: string) => {
+ let chatHistory = '';
+ if (!_separator) {
+ _separator = '\n\n';
+ }
+ if (_sessionId) {
+ const redisWrapperInst = getRedis();
+ const chatHistoryName = 'chatHistory:' + _sessionId;
+ const items = await redisWrapperInst.getAllItemsFromList(chatHistoryName);
+
+ if (items?.length) {
+ chatHistory = items.join(_separator);
+ }
+ }
+ return chatHistory;
+};
+const combineVectorDocuments = (
+ _vectorDocs: Document[],
+ _separator?: string,
+) => {
+ if (!_separator) {
+ _separator = '\n\n --------------------- \n\n';
+ }
+ return _vectorDocs.map((doc) => doc.pageContent).join(_separator);
+};
+```
+
+Below function uses `Redis` to find similar products for the standaloneQuestion
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+// (2) Get similar products from Redis
+const getSimilarProductsByVSS = async (
+ _standAloneQuestion: string,
+ _openAIApiKey: string,
+) => {
+ const client = getNodeRedisClient();
+
+ const embeddings = new OpenAIEmbeddings({
+ openAIApiKey: _openAIApiKey,
+ });
+ const vectorStore = new RedisVectorStore(embeddings, {
+ redisClient: client,
+ indexName: 'openAIProductsIdx',
+ keyPrefix: 'openAIProducts:',
+ });
+
+ const KNN = 3;
+ /* Simple standalone search in the vector DB */
+ const vectorDocs = await vectorStore.similaritySearch(
+ _standAloneQuestion,
+ KNN,
+ );
+
+ return vectorDocs;
+};
+```
+
+Below function uses `openAI` to convert the standaloneQuestion, similar products from Redis and other context to a human understandable answer.
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+// (3) Get answer from OpenAI
+const convertToAnswer = async (
+ _originalQuestion: string,
+ _standAloneQuestion: string,
+ _productDetails: string,
+ _sessionId: string,
+ _openAIApiKey: string,
+) => {
+ const llm = getOpenAIInstance(_openAIApiKey);
+
+ const chatHistory = await getChatHistory(_sessionId);
+
+ const answerTemplate = `
+ Please assume the persona of a retail shopping assistant for this conversation.
+ Use a friendly tone, and assume the target audience are normal people looking for a product in a ecommerce website.
+
+ ***********************************************************
+ ${
+ chatHistory
+ ? `
+ Conversation history between user and you is :
+ ${chatHistory}
+ `
+ : ''
+ }
+ ***********************************************************
+ OriginalQuestion of user is : {originalQuestion}
+ ***********************************************************
+ converted stand alone question is : {standAloneQuestion}
+ ***********************************************************
+ resulting details of products for the stand alone question are :
+ {productDetails}
+ Note : Different product details are separated by "---------------------" (if any)
+ ***********************************************************
+ Answer the question based on the context provided and the conversation history.
+
+ If you don't know the answer, please direct the questioner to email help@redis.com. Don't try to suggest any product out of context as it may not be in the store.
+
+ Let the answer include product display name, price and optional other details based on question asked.
+
+ Let the product display name be a link like productDisplayName
+ so that user can click on it and go to the product page with help of productId.
+
+ answer: `;
+
+ const answerPrompt = PromptTemplate.fromTemplate(answerTemplate);
+ const chain = answerPrompt.pipe(llm).pipe(new StringOutputParser());
+
+ const response = await chain.invoke({
+ originalQuestion: _originalQuestion,
+ standAloneQuestion: _standAloneQuestion,
+ productDetails: _productDetails,
+ });
+
+ return response;
+};
+```
+
+You can observe chat history and intermediate chat logs in RedisInsight:
+
+
+
+
+
+:::tip
+
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to visually explore your Redis data or to engage with raw Redis commands in the workbench.
+
+:::
+
+## Ready to use Redis for genAI chatbot?
+
+Building a GenAI chatbot using LangChain and Redis involves integrating advanced AI models with efficient storage solutions. This tutorial covers the fundamental steps and code needed to develop a chatbot capable of handling e-commerce queries. With these tools, you can create a responsive, intelligent chatbot for a variety of applications
+
+## Further reading
+
+- [Perform vector similarity search using Redis](/howtos/solutions/vector/getting-started-vector)
+
+- [LangChain JS](https://js.langchain.com/docs/get_started/quickstart)
+ - [Learn LangChain](https://scrimba.com/learn/langchain)
+- [LangChain redis integration](https://js.langchain.com/docs/integrations/vectorstores/redis)
diff --git a/docs/howtos/solutions/vector/getting-started-vector/chart/common.js b/docs/howtos/solutions/vector/getting-started-vector/chart/common.js
new file mode 100644
index 00000000000..c5f990909c5
--- /dev/null
+++ b/docs/howtos/solutions/vector/getting-started-vector/chart/common.js
@@ -0,0 +1,30 @@
+// Sample data
+const products = [
+ {
+ name: 'Puma Men Race Black Watch',
+ price: 150,
+ quality: 5,
+ popularity: 8,
+ },
+ {
+ name: 'Puma Men Top Fluctuation Red Black Watch',
+ price: 180,
+ quality: 7,
+ popularity: 6,
+ },
+ {
+ name: 'Inkfruit Women Behind Cream Tshirt',
+ price: 5,
+ quality: 9,
+ popularity: 7,
+ },
+];
+
+const dataWithAttributes = products.map((product) => ({
+ x: product.price,
+ y: product.quality,
+ label: product.name,
+}));
+
+const product1Point = { x: products[0].price, y: products[0].quality };
+const product2Point = { x: products[1].price, y: products[1].quality };
diff --git a/docs/howtos/solutions/vector/getting-started-vector/chart/cosine.js b/docs/howtos/solutions/vector/getting-started-vector/chart/cosine.js
new file mode 100644
index 00000000000..2035affa807
--- /dev/null
+++ b/docs/howtos/solutions/vector/getting-started-vector/chart/cosine.js
@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
+const ctxCosine = document
+ .getElementById('productChartCosine')
+ .getContext('2d');
+
+function cosineSimilarity(point1, point2) {
+ let dotProduct = point1.x * point2.x + point1.y * point2.y;
+ let magnitudePoint1 = Math.sqrt(
+ Math.pow(point1.x, 2) + Math.pow(point1.y, 2),
+ );
+ let magnitudePoint2 = Math.sqrt(
+ Math.pow(point2.x, 2) + Math.pow(point2.y, 2),
+ );
+ return dotProduct / (magnitudePoint1 * magnitudePoint2);
+}
+
+const cosineSim = cosineSimilarity(product1Point, product2Point);
+
+const scatterChartCosine = new Chart(ctxCosine, {
+ type: 'scatter',
+ data: {
+ datasets: [
+ {
+ label: 'Products',
+ data: dataWithAttributes,
+ pointBackgroundColor: ['black', 'red', 'bisque'],
+ pointRadius: 5,
+ },
+ {
+ label: 'Vector for Product-1',
+ data: [{ x: 0, y: 0 }, product1Point],
+ showLine: true,
+ fill: false,
+ borderColor: 'black',
+ pointRadius: [0, 5],
+ lineTension: 0,
+ },
+ {
+ label: 'Vector for Product-2',
+ data: [{ x: 0, y: 0 }, product2Point],
+ showLine: true,
+ fill: false,
+ borderColor: 'red',
+ pointRadius: [0, 5],
+ lineTension: 0,
+ },
+ ],
+ },
+ options: {
+ responsive: true,
+ plugins: {
+ legend: {
+ position: 'top',
+ },
+ title: {
+ display: true,
+ text: `Cosine Similarity between Product-1 and Product-2 is ${cosineSim}`,
+ },
+ },
+ scales: {
+ x: {
+ type: 'linear',
+ position: 'bottom',
+ title: {
+ display: true,
+ text: 'Price ($)',
+ },
+ ticks: {
+ beginAtZero: true,
+ },
+ min: 0, // Ensure it starts from 0
+ },
+ y: {
+ title: {
+ display: true,
+ text: 'Quality (1-10)',
+ },
+ ticks: {
+ beginAtZero: true,
+ },
+ min: 0, // Ensure it starts from 0
+ },
+ },
+ tooltips: {
+ callbacks: {
+ title: function (tooltipItem, data) {
+ return data.datasets[0].data[tooltipItem[0].index].label;
+ },
+ },
+ },
+ },
+});
diff --git a/docs/howtos/solutions/vector/getting-started-vector/chart/euclidean.js b/docs/howtos/solutions/vector/getting-started-vector/chart/euclidean.js
new file mode 100644
index 00000000000..15fce10c435
--- /dev/null
+++ b/docs/howtos/solutions/vector/getting-started-vector/chart/euclidean.js
@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+const ctx = document.getElementById('productChartEuclidean').getContext('2d');
+
+function euclideanDistance(point1, point2) {
+ return Math.sqrt(
+ Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2),
+ );
+}
+
+const distance = euclideanDistance(product1Point, product2Point);
+
+const scatterChart = new Chart(ctx, {
+ type: 'scatter',
+ data: {
+ datasets: [
+ {
+ label: 'Products',
+ data: dataWithAttributes,
+ pointBackgroundColor: ['black', 'red', 'bisque'],
+ pointRadius: 5,
+ },
+ {
+ label: `Euclidean Distance: ${distance.toFixed(2)}`,
+ data: [product1Point, product2Point],
+ showLine: true,
+ fill: false,
+ borderColor: 'green',
+ pointRadius: 0,
+ lineTension: 0,
+ },
+ ],
+ },
+ options: {
+ responsive: true,
+ plugins: {
+ legend: {
+ position: 'top',
+ },
+ title: {
+ display: true,
+ text: `Euclidean Distance between Product-1 and Product-2`,
+ },
+ },
+ scales: {
+ x: {
+ type: 'linear',
+ position: 'bottom',
+ title: {
+ display: true,
+ text: 'Price ($)',
+ },
+ ticks: {
+ beginAtZero: true,
+ },
+ min: 0, // Ensure it starts from 0
+ },
+ y: {
+ title: {
+ display: true,
+ text: 'Quality (1-10)',
+ },
+ ticks: {
+ beginAtZero: true,
+ },
+ min: 0, // Ensure it starts from 0
+ },
+ },
+ tooltips: {
+ callbacks: {
+ title: function (tooltipItem, data) {
+ // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+ return data.datasets[0].data[tooltipItem[0].index].label;
+ },
+ },
+ },
+ },
+});
diff --git a/docs/howtos/solutions/vector/getting-started-vector/chart/index.html b/docs/howtos/solutions/vector/getting-started-vector/chart/index.html
new file mode 100644
index 00000000000..c089045aa21
--- /dev/null
+++ b/docs/howtos/solutions/vector/getting-started-vector/chart/index.html
@@ -0,0 +1,28 @@
+
+
+
+
+ Product Attributes Visualization
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/11001.jpg b/docs/howtos/solutions/vector/getting-started-vector/images/11001.jpg
new file mode 100644
index 00000000000..6366a8dda81
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/11001.jpg differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/cosine-chart.png b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-chart.png
new file mode 100644
index 00000000000..073ef9709b9
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-chart.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/cosine-formula.png b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-formula.png
new file mode 100644
index 00000000000..51b7ab52438
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-formula.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/cosine-sample.png b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-sample.png
new file mode 100644
index 00000000000..cdcbb0beef4
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/cosine-sample.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-chart.png b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-chart.png
new file mode 100644
index 00000000000..7e8d13b29f0
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-chart.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-formula.png b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-formula.png
new file mode 100644
index 00000000000..8cbaa051809
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-formula.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-sample.png b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-sample.png
new file mode 100644
index 00000000000..10c4103d325
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/euclidean-distance-sample.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/ip-formula.png b/docs/howtos/solutions/vector/getting-started-vector/images/ip-formula.png
new file mode 100644
index 00000000000..2f1912d7c99
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/ip-formula.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/ip-sample.png b/docs/howtos/solutions/vector/getting-started-vector/images/ip-sample.png
new file mode 100644
index 00000000000..5c29c8ba6e3
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/ip-sample.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/images/products-data-gui.png b/docs/howtos/solutions/vector/getting-started-vector/images/products-data-gui.png
new file mode 100644
index 00000000000..df6021442c9
Binary files /dev/null and b/docs/howtos/solutions/vector/getting-started-vector/images/products-data-gui.png differ
diff --git a/docs/howtos/solutions/vector/getting-started-vector/index-getting-started-vector.mdx b/docs/howtos/solutions/vector/getting-started-vector/index-getting-started-vector.mdx
new file mode 100644
index 00000000000..a0fa5e800d2
--- /dev/null
+++ b/docs/howtos/solutions/vector/getting-started-vector/index-getting-started-vector.mdx
@@ -0,0 +1,811 @@
+---
+id: index-getting-started-vector
+title: How to Perform Vector Similarity Search Using Redis in NodeJS
+sidebar_label: How to Perform Vector Similarity Search Using Redis in NodeJS
+slug: /howtos/solutions/vector/getting-started-vector
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import SampleWatchImage from './images/11001.jpg';
+import EuclideanDistanceFormulaImage from './images/euclidean-distance-formula.png';
+import EuclideanDistanceSampleImage from './images/euclidean-distance-sample.png';
+import CosineFormulaImage from './images/cosine-formula.png';
+import CosineSampleImage from './images/cosine-sample.png';
+import IpFormulaImage from './images/ip-formula.png';
+import IpSampleImage from './images/ip-sample.png';
+
+
+
+## What you Will learn in this tutorial
+
+This tutorial is a comprehensive guide to leveraging Redis for vector similarity search in a NodeJS environment. Aimed at software developers with expertise in the NodeJS/ JavaScript ecosystem, this tutorial will provide you with the knowledge and techniques required for advanced vector operations. Here's what's covered:
+
+- [Foundational Concepts](./#vectors-introduction):
+
+ - [About Vectors](./#what-is-a-vector-in-machine-learning): Delve into the foundational concept of vectors in machine learning.
+ - [Vector Databases](./#what-is-a-vector-database): Understand specialized databases designed to handle vector data efficiently.
+ - [Vector Similarity](./#what-is-vector-similarity): Grasp the concept and significance of comparing vectors. Discover some use cases where vector similarity plays a pivotal role, from recommendation systems to content retrieval.
+
+- [Vector Generation](./#generating-vectors):
+
+ - [Textual Content](./#sentence-text-vector): Learn techniques to generate vectors from textual data.
+ - [Imagery Content](./#image-vector): Understand how images can be represented as vectors and how they're processed.
+
+- [Redis Database Setup](./#database-setup):
+
+ - [Data Seeding](./#sample-data-seeding): Get hands-on with populating your Redis database with vector data.
+ - [Index Creation](./#create-vector-index): Understand the process of indexing vector fields in Redis, optimizing for both accuracy and performance.
+
+- Advanced Vector Queries in Redis:
+
+ - [KNN (k-Nearest Neighbors) Queries](./#what-is-vector-knn-query): Dive into the concept of KNN and its implementation in Redis to retrieve vectors most similar to a query vector.
+ - [Range Queries](./#what-is-vector-range-query): Discover how to retrieve vectors within a certain distance or range from a target vector.
+
+- [Vector Similarity Calculations](./#how-to-calculate-vector-similarity): (Optionally) if you want to understand the math behind vector similarity search
+
+ - [Euclidean Distance](./#euclidean-distance-l2-norm): Understand the L2 norm method for calculating similarity.
+ - [Cosine Similarity](./#cosine-similarity): Dive into the angular differences and its importance in vector space.
+ - [Inner Product](./#inner-product): Learn about another essential metric in understanding vector similarities.
+
+- [Additional Resources](./#further-reading): Take your learning further with other resources related to vectors in Redis.
+
+## Vectors introduction
+
+### What is a vector in machine learning?
+
+In the context of machine learning, a vector is a mathematical representation of data. It is an ordered list of numbers that encode the features or attributes of a piece of data.
+
+Vectors can be thought of as points in a multi-dimensional space where each dimension corresponds to a feature.
+**For example**, consider a simple dataset about ecommerce `products`. Each product might have features such as `price`, `quality`, and `popularity`.
+
+| Id | Product | Price ($) | Quality (1 - 10) | Popularity (1 - 10) |
+| --- | ---------------------------------------- | --------- | ---------------- | ------------------- |
+| 1 | Puma Men Race Black Watch | 150 | 5 | 8 |
+| 2 | Puma Men Top Fluctuation Red Black Watch | 180 | 7 | 6 |
+| 3 | Inkfruit Women Behind Cream Tshirt | 5 | 9 | 7 |
+
+Now, product 1 `Puma Men Race Black Watch` might be represented as the vector `[150, 5, 8]`
+
+In a more complex scenario, like natural language processing (NLP), words or entire sentences can be converted into dense vectors (often referred to as embeddings) that capture the semantic meaning of the text.Vectors play a foundational role in many machine learning algorithms, particularly those that involve distance measurements, such as clustering and classification algorithms.
+
+### What is a vector database?
+
+A vector database is a specialized system optimized for storing and searching vectors. Designed explicitly for efficiency, these databases play a crucial role in powering vector search applications, including recommendation systems, image search, and textual content retrieval. Often referred to as vector stores, vector indexes, or vector search engines, these databases employ vector similarity algorithms to identify vectors that closely match a given query vector.
+
+:::tip
+
+[**Redis Cloud**](https://redis.com/try-free) is a popular choice for vector databases, as it offers a rich set of data structures and commands that are well-suited for vector storage and search. Redis Cloud allows you to index vectors and perform vector similarity search in a few different ways outlined further in this tutorial. It also maintains a high level of performance and scalability.
+
+:::
+
+### What is vector similarity?
+
+Vector similarity is a measure that quantifies how alike two vectors are, typically by evaluating the `distance` or `angle` between them in a multi-dimensional space.
+When vectors represent data points, such as texts or images, the similarity score can indicate how similar the underlying data points are in terms of their features or content.
+
+**Use cases for vector similarity:**
+
+- **Recommendation Systems**: If you have vectors representing user preferences or item profiles, you can quickly find items that are most similar to a user's preference vector.
+- **Image Search**: Store vectors representing image features, and then retrieve images most similar to a given image's vector.
+- **Textual Content Retrieval**: Store vectors representing textual content (e.g., articles, product descriptions) and find the most relevant texts for a given query vector.
+
+:::tip CALCULATING VECTOR SIMILARITY
+
+If you're interested in learning more about the mathematics behind vector similarity, scroll down to the [**How to calculate vector similarity?**](#how-to-calculate-vector-similarity) section.
+
+:::
+
+## Generating vectors
+
+In our scenario, our focus revolves around generating sentence (product description) and image (product image) embeddings or vectors. There's an abundance of AI model repositories, like GitHub, where AI models are pre-trained, maintained, and shared.
+
+For sentence embeddings, we'll employ a model from [Hugging Face Model Hub](https://huggingface.co/models), and for image embeddings, one from [TensorFlow Hub](https://tfhub.dev/) will be leveraged for variety.
+
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code used in this tutorial
+
+git clone https://github.com/redis-developer/redis-vector-nodejs-solutions.git
+:::
+
+### Sentence/ text vector
+
+To generate sentence embeddings, we'll make use of a Hugging Face model titled [Xenova/all-distilroberta-v1](https://huggingface.co/Xenova/all-distilroberta-v1). It's a compatible version of [sentence-transformers/all-distilroberta-v1](https://huggingface.co/sentence-transformers/all-distilroberta-v1) for transformer.js with ONNX weights.
+
+:::info
+
+[Hugging Face Transformers](https://huggingface.co/docs/transformers.js/index)
+is a renowned open-source tool for Natural Language Processing (NLP) tasks.
+It simplifies the use of cutting-edge NLP models.
+
+The transformers.j library is essentially the JavaScript version of Hugging Face's popular Python library.
+
+:::
+
+:::info
+
+[ONNX (Open Neural Network eXchange)](https://onnx.ai) is an open standard
+that defines a common set of operators and a common file format to represent deep
+learning models in a wide variety of frameworks, including PyTorch and TensorFlow
+
+:::
+
+Below, you'll find a Node.js code snippet that illustrates how to create vector embeddings for any provided `sentence`:
+
+```sh
+npm install @xenova/transformers
+```
+
+```js title="src/text-vector-gen.ts"
+import * as transformers from '@xenova/transformers';
+
+async function generateSentenceEmbeddings(_sentence): Promise {
+ let modelName = 'Xenova/all-distilroberta-v1';
+ let pipe = await transformers.pipeline('feature-extraction', modelName);
+
+ let vectorOutput = await pipe(_sentence, {
+ pooling: 'mean',
+ normalize: true,
+ });
+
+ const embeddings: number[] = Object.values(vectorOutput?.data);
+ return embeddings;
+}
+
+export { generateSentenceEmbeddings };
+```
+
+Here's a glimpse of the vector output for a sample text:
+
+```js title="sample output"
+const embeddings = await generateSentenceEmbeddings('I Love Redis !');
+console.log(embeddings);
+/*
+ 768 dim vector output
+ embeddings = [
+ -0.005076113156974316, -0.006047232076525688, -0.03189406543970108,
+ -0.019677048549056053, 0.05152582749724388, -0.035989608615636826,
+ -0.009754283353686333, 0.002385444939136505, -0.04979122802615166,
+ ....]
+*/
+```
+
+### Image vector
+
+To obtain image embeddings, we'll leverage the [mobilenet](https://github.com/tensorflow/tfjs-models/tree/master/mobilenet) model from TensorFlow.
+
+Below, you'll find a Node.js code snippet that illustrates how to create vector embeddings for any provided `image`:
+
+```sh
+npm i @tensorflow/tfjs @tensorflow/tfjs-node @tensorflow-models/mobilenet jpeg-js
+```
+
+```js title="src/image-vector-gen.ts"
+import * as tf from '@tensorflow/tfjs-node';
+import * as mobilenet from '@tensorflow-models/mobilenet';
+
+import * as jpeg from 'jpeg-js';
+
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs/promises';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function decodeImage(imagePath) {
+ imagePath = path.join(__dirname, imagePath);
+
+ const buffer = await fs.readFile(imagePath);
+ const rawImageData = jpeg.decode(buffer);
+ const imageTensor = tf.browser.fromPixels(rawImageData);
+ return imageTensor;
+}
+
+async function generateImageEmbeddings(imagePath: string) {
+ const imageTensor = await decodeImage(imagePath);
+
+ // Load MobileNet model
+ const model = await mobilenet.load();
+
+ // Classify and predict what the image is
+ const prediction = await model.classify(imageTensor);
+ console.log(`${imagePath} prediction`, prediction);
+
+ // Preprocess the image and get the intermediate activation.
+ const activation = model.infer(imageTensor, true);
+
+ // Convert the tensor to a regular array.
+ const vectorOutput = await activation.data();
+
+ imageTensor.dispose(); // Clean up tensor
+
+ return vectorOutput; //DIM 1024
+}
+```
+
+
+
+
+
+:::tip Image classification model
+
+We are using [mobilenet model](https://github.com/tensorflow/tfjs-models/tree/master/mobilenet) which is trained only on small [set of image classes](https://github.com/tensorflow/tfjs-examples/blob/master/mobilenet/imagenet_classes.js). The choice of an image classification model depends on various factors, such as the dataset size, dataset diversity, computational resources, and the specific requirements of your application. There are various alternative image classification models, such as EfficientNet, ResNets, and Vision Transformers (ViT), that you can select based on your needs.
+:::
+
+Below is an illustration of the vector output for a sample watch image:
+
+
+
+
+
+
This watch from puma comes in a heavy duty design. The asymmetric dial and chunky casing gives this watch a tough appearance perfect for navigating the urban jungle.
Dial shape: Round
Case diameter: 32 cm
Warranty: 2 Years
Stainless steel case with a fixed bezel for added durability, style and comfort
Leather straps with a tang clasp for comfort and style
Black dial with cat logo on the 12 hour mark
Date aperture at the 3 hour mark
Analog time display
Solid case back made of stainless steel for enhanced durability
Water resistant upto 100 metres
',
+ },
+ {
+ _id: '2',
+ price: 5450,
+ productDisplayName: 'Puma Men Top Fluctuation Red Black Watches',
+ brandName: 'Puma',
+ ageGroup: 'Adults-Men',
+ gender: 'Men',
+ masterCategory: 'Accessories',
+ subCategory: 'Watches',
+ imageURL: 'images/11001.jpg',
+ productDescription:
+ 'This watch from puma comes in a clean sleek design. This active watch is perfect for urban wear and can serve you well in the gym or a night of clubbing.
Case diameter: 40 mm<
',
+ },
+
+ {
+ _id: '3',
+ price: 499,
+ productDisplayName: 'Inkfruit Women Behind Cream Tshirts',
+ brandName: 'Inkfruit',
+ ageGroup: 'Adults-Women',
+ gender: 'Women',
+ masterCategory: 'Apparel',
+ subCategory: 'Topwear',
+ imageURL: 'images/11008.jpg',
+ productDescription:
+ 'Composition
Yellow round neck t-shirt made of 100% cotton, has short sleeves and graphic print on the front
Fitting
Comfort
Wash care
Hand wash separately in cool water at 30 degrees
Do not scrub
Do not bleach
Turn inside out and dry flat in shade
Warm iron on reverse
Do not iron on print
Flaunt your pretty, long legs in style with this inkfruit t-shirt. The graphic print oozes sensuality, while the cotton fabric keeps you fresh and comfortable all day. Team this with a short denim skirt and high-heeled sandals and get behind the wheel in style.
Model statistics
The model wears size M in t-shirts
Height: 5\'7", Chest: 33"
',
+ },
+];
+```
+
+Below is the sample code to seed `products` data as JSON in Redis. The data also includes vectors of both product descriptions and images.
+
+```js title="src/index.ts"
+async function addProductWithEmbeddings(_products) {
+ const nodeRedisClient = getNodeRedisClient();
+
+ if (_products && _products.length) {
+ for (let product of _products) {
+ console.log(
+ `generating description embeddings for product ${product._id}`,
+ );
+ const sentenceEmbedding = await generateSentenceEmbeddings(
+ product.productDescription,
+ );
+ product['productDescriptionEmbeddings'] = sentenceEmbedding;
+
+ console.log(`generating image embeddings for product ${product._id}`);
+ const imageEmbedding = await generateImageEmbeddings(product.imageURL);
+ product['productImageEmbeddings'] = imageEmbedding;
+
+ await nodeRedisClient.json.set(`products:${product._id}`, '$', {
+ ...product,
+ });
+ console.log(`product ${product._id} added to redis`);
+ }
+ }
+}
+```
+
+You can observe products JSON data in RedisInsight:
+
+
+
+:::tip
+
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to visually explore your Redis data or to engage with raw Redis commands in the workbench.
+
+:::
+
+### Create vector index
+
+For searches to be conducted on JSON fields in Redis, they must be indexed. The methodology below highlights the process of indexing different types of fields. This encompasses vector fields such as `productDescriptionEmbeddings` and `productImageEmbeddings`.
+
+```ts title="src/redis-index.ts"
+import {
+ createClient,
+ SchemaFieldTypes,
+ VectorAlgorithms,
+ RediSearchSchema,
+} from 'redis';
+
+const PRODUCTS_KEY_PREFIX = 'products';
+const PRODUCTS_INDEX_KEY = 'idx:products';
+const REDIS_URI = 'redis://localhost:6379';
+let nodeRedisClient = null;
+
+const getNodeRedisClient = async () => {
+ if (!nodeRedisClient) {
+ nodeRedisClient = createClient({ url: REDIS_URI });
+ await nodeRedisClient.connect();
+ }
+ return nodeRedisClient;
+};
+
+const createRedisIndex = async () => {
+ /* (RAW COMMAND)
+ FT.CREATE idx:products
+ ON JSON
+ PREFIX 1 "products:"
+ SCHEMA
+ "$.productDisplayName" as productDisplayName TEXT NOSTEM SORTABLE
+ "$.brandName" as brandName TEXT NOSTEM SORTABLE
+ "$.price" as price NUMERIC SORTABLE
+ "$.masterCategory" as "masterCategory" TAG
+ "$.subCategory" as subCategory TAG
+ "$.productDescriptionEmbeddings" as productDescriptionEmbeddings VECTOR "FLAT" 10
+ "TYPE" FLOAT32
+ "DIM" 768
+ "DISTANCE_METRIC" "L2"
+ "INITIAL_CAP" 111
+ "BLOCK_SIZE" 111
+ "$.productDescription" as productDescription TEXT NOSTEM SORTABLE
+ "$.imageURL" as imageURL TEXT NOSTEM
+ "$.productImageEmbeddings" as productImageEmbeddings VECTOR "HNSW" 8
+ "TYPE" FLOAT32
+ "DIM" 1024
+ "DISTANCE_METRIC" "COSINE"
+ "INITIAL_CAP" 111
+
+ */
+ const nodeRedisClient = await getNodeRedisClient();
+
+ const schema: RediSearchSchema = {
+ '$.productDisplayName': {
+ type: SchemaFieldTypes.TEXT,
+ NOSTEM: true,
+ SORTABLE: true,
+ AS: 'productDisplayName',
+ },
+ '$.brandName': {
+ type: SchemaFieldTypes.TEXT,
+ NOSTEM: true,
+ SORTABLE: true,
+ AS: 'brandName',
+ },
+ '$.price': {
+ type: SchemaFieldTypes.NUMERIC,
+ SORTABLE: true,
+ AS: 'price',
+ },
+ '$.masterCategory': {
+ type: SchemaFieldTypes.TAG,
+ AS: 'masterCategory',
+ },
+ '$.subCategory': {
+ type: SchemaFieldTypes.TAG,
+ AS: 'subCategory',
+ },
+ '$.productDescriptionEmbeddings': {
+ type: SchemaFieldTypes.VECTOR,
+ TYPE: 'FLOAT32',
+ ALGORITHM: VectorAlgorithms.FLAT,
+ DIM: 768,
+ DISTANCE_METRIC: 'L2',
+ INITIAL_CAP: 111,
+ BLOCK_SIZE: 111,
+ AS: 'productDescriptionEmbeddings',
+ },
+ '$.productDescription': {
+ type: SchemaFieldTypes.TEXT,
+ NOSTEM: true,
+ SORTABLE: true,
+ AS: 'productDescription',
+ },
+ '$.imageURL': {
+ type: SchemaFieldTypes.TEXT,
+ NOSTEM: true,
+ AS: 'imageURL',
+ },
+ '$.productImageEmbeddings': {
+ type: SchemaFieldTypes.VECTOR,
+ TYPE: 'FLOAT32',
+ ALGORITHM: VectorAlgorithms.HNSW, //Hierarchical Navigable Small World graphs
+ DIM: 1024,
+ DISTANCE_METRIC: 'COSINE',
+ INITIAL_CAP: 111,
+ AS: 'productImageEmbeddings',
+ },
+ };
+ console.log(`index ${PRODUCTS_INDEX_KEY} created`);
+
+ try {
+ await nodeRedisClient.ft.dropIndex(PRODUCTS_INDEX_KEY);
+ } catch (indexErr) {
+ console.error(indexErr);
+ }
+ await nodeRedisClient.ft.create(PRODUCTS_INDEX_KEY, schema, {
+ ON: 'JSON',
+ PREFIX: PRODUCTS_KEY_PREFIX,
+ });
+};
+```
+
+:::info FLAT VS HNSW indexing
+
+FLAT: When vectors are indexed in a "FLAT" structure, they're stored in their original form without any added hierarchy. A search against a FLAT index will require the algorithm to scan each vector linearly to find the most similar matches. While this is accurate, it's computationally intensive and slower, making it ideal for smaller datasets.
+
+HNSW (Hierarchical Navigable Small World): HNSW is a graph-centric method tailored for indexing high-dimensional data. With larger datasets, linear comparisons against every vector in the index become time-consuming. HNSW employs a probabilistic approach, ensuring faster search results but with a slight trade-off in accuracy.
+
+:::
+
+:::info INITIAL_CAP and BLOCK_SIZE parameters
+
+Both INITIAL_CAP and BLOCK_SIZE are configuration parameters that control how vectors are stored and indexed.
+
+INITIAL_CAP defines the initial capacity of the vector index. It helps in pre-allocating space for the index.
+
+BLOCK_SIZE defines the size of each block of the vector index. As more vectors are added, Redis will allocate memory in chunks, with each chunk being the size of the BLOCK_SIZE. It helps in optimizing the memory allocations during index growth.
+
+:::
+
+## What is vector KNN query?
+
+KNN, or k-Nearest Neighbors, is an algorithm used in both classification and regression tasks, but when referring to "KNN Search," we're typically discussing the task of finding the "k" points in a dataset that are closest (most similar) to a given query point. In the context of vector search, this means identifying the "k" vectors in our database that are most similar to a given query vector, usually based on some distance metric like cosine similarity or Euclidean distance.
+
+### Vector KNN query with Redis
+
+Redis allows you to index and then search for vectors [using the KNN approach](https://redis.io/docs/interact/search-and-query/search/vectors/).
+
+Below, you'll find a Node.js code snippet that illustrates how to perform `KNN query` for any provided `search text`:
+
+```ts title="src/knn-query.ts"
+const float32Buffer = (arr) => {
+ const floatArray = new Float32Array(arr);
+ const float32Buffer = Buffer.from(floatArray.buffer);
+ return float32Buffer;
+};
+const queryProductDescriptionEmbeddingsByKNN = async (
+ _searchTxt,
+ _resultCount,
+) => {
+ //A KNN query will give us the top n documents that best match the query vector.
+
+ /* sample raw query
+
+ FT.SEARCH idx:products
+ "*=>[KNN 5 @productDescriptionEmbeddings $searchBlob AS score]"
+ RETURN 4 score brandName productDisplayName imageURL
+ SORTBY score
+ PARAMS 2 searchBlob "6\xf7\..."
+ DIALECT 2
+
+ */
+ //https://redis.io/docs/interact/search-and-query/query/
+
+ console.log(`queryProductDescriptionEmbeddingsByKNN started`);
+ let results = {};
+ if (_searchTxt) {
+ _resultCount = _resultCount ?? 5;
+
+ const nodeRedisClient = getNodeRedisClient();
+ const searchTxtVectorArr = await generateSentenceEmbeddings(_searchTxt);
+
+ const searchQuery = `*=>[KNN ${_resultCount} @productDescriptionEmbeddings $searchBlob AS score]`;
+
+ results = await nodeRedisClient.ft.search(PRODUCTS_INDEX_KEY, searchQuery, {
+ PARAMS: {
+ searchBlob: float32Buffer(searchTxtVectorArr),
+ },
+ RETURN: ['score', 'brandName', 'productDisplayName', 'imageURL'],
+ SORTBY: {
+ BY: 'score',
+ // DIRECTION: "DESC"
+ },
+ DIALECT: 2,
+ });
+ } else {
+ throw 'Search text cannot be empty';
+ }
+
+ return results;
+};
+```
+
+Please find output for a KNN query in Redis **(A lower score or distance in the output signifies a higher degree of similarity.)**
+
+```js title="sample output"
+const result = await queryProductDescriptionEmbeddingsByKNN(
+ 'Puma watch with cat', //search text
+ 3, //max number of results expected
+);
+console.log(JSON.stringify(result, null, 4));
+
+/*
+{
+ "total": 3,
+ "documents": [
+ {
+ "id": "products:1",
+ "value": {
+ "score": "0.762174725533",
+ "brandName": "Puma",
+ "productDisplayName": "Puma Men Race Black Watch",
+ "imageURL": "images/11002.jpg"
+ }
+ },
+ {
+ "id": "products:2",
+ "value": {
+ "score": "0.825711071491",
+ "brandName": "Puma",
+ "productDisplayName": "Puma Men Top Fluctuation Red Black Watches",
+ "imageURL": "images/11001.jpg"
+ }
+ },
+ {
+ "id": "products:3",
+ "value": {
+ "score": "1.79949247837",
+ "brandName": "Inkfruit",
+ "productDisplayName": "Inkfruit Women Behind Cream Tshirts",
+ "imageURL": "images/11008.jpg"
+ }
+ }
+ ]
+}
+*/
+```
+
+:::note
+KNN queries can be combined with standard Redis search functionalities using [Hybrid queries](https://redis.io/docs/interact/search-and-query/search/vectors/#hybrid-knn-queries).
+:::
+
+## What is vector range query?
+
+Range queries retrieve data that falls within a specified range of values.
+For vectors, a "range query" typically refers to retrieving all vectors within a certain distance of a target vector. The "range" in this context is a radius in the vector space.
+
+### Vector range query with Redis
+
+Below, you'll find a Node.js code snippet that illustrates how to perform vector `range query` for any range (radius/ distance)provided:
+
+```js title="src/range-query.ts"
+const queryProductDescriptionEmbeddingsByRange = async (_searchTxt, _range) => {
+ /* sample raw query
+
+ FT.SEARCH idx:products
+ "@productDescriptionEmbeddings:[VECTOR_RANGE $searchRange $searchBlob]=>{$YIELD_DISTANCE_AS: score}"
+ RETURN 4 score brandName productDisplayName imageURL
+ SORTBY score
+ PARAMS 4 searchRange 0.685 searchBlob "A=\xe1\xbb\x8a\xad\x...."
+ DIALECT 2
+ */
+
+ console.log(`queryProductDescriptionEmbeddingsByRange started`);
+ let results = {};
+ if (_searchTxt) {
+ _range = _range ?? 1.0;
+
+ const nodeRedisClient = getNodeRedisClient();
+
+ const searchTxtVectorArr = await generateSentenceEmbeddings(_searchTxt);
+
+ const searchQuery =
+ '@productDescriptionEmbeddings:[VECTOR_RANGE $searchRange $searchBlob]=>{$YIELD_DISTANCE_AS: score}';
+
+ results = await nodeRedisClient.ft.search(PRODUCTS_INDEX_KEY, searchQuery, {
+ PARAMS: {
+ searchBlob: float32Buffer(searchTxtVectorArr),
+ searchRange: _range,
+ },
+ RETURN: ['score', 'brandName', 'productDisplayName', 'imageURL'],
+ SORTBY: {
+ BY: 'score',
+ // DIRECTION: "DESC"
+ },
+ DIALECT: 2,
+ });
+ } else {
+ throw 'Search text cannot be empty';
+ }
+
+ return results;
+};
+```
+
+Please find output for a range query in Redis
+
+```js title="sample output"
+const result2 = await queryProductDescriptionEmbeddingsByRange(
+ 'Puma watch with cat', //search text
+ 1.0, //with in range or distance
+);
+console.log(JSON.stringify(result2, null, 4));
+/*
+{
+ "total": 2,
+ "documents": [
+ {
+ "id": "products:1",
+ "value": {
+ "score": "0.762174725533",
+ "brandName": "Puma",
+ "productDisplayName": "Puma Men Race Black Watch",
+ "imageURL": "images/11002.jpg"
+ }
+ },
+ {
+ "id": "products:2",
+ "value": {
+ "score": "0.825711071491",
+ "brandName": "Puma",
+ "productDisplayName": "Puma Men Top Fluctuation Red Black Watches",
+ "imageURL": "images/11001.jpg"
+ }
+ }
+ ]
+}
+*/
+```
+
+## Image vs text vector query
+
+:::info Image vs text vector query
+The syntax for vector KNN/ range queries is consistent, regardless of whether you're working with image vectors or text vectors. Just as there's a method for text vector queries named `queryProductDescriptionEmbeddingsByKNN`, there's a corresponding method for images titled `queryProductImageEmbeddingsByKNN` in the code base.
+:::
+
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code used in this tutorial
+
+git clone https://github.com/redis-developer/redis-vector-nodejs-solutions.git
+:::
+
+Hopefully this tutorial has helped you visualize how to use Redis for vector similarity search.
+
+---
+
+(Optional) If you want to also understand the math behind vector similarity search , then read following
+
+## How to calculate vector similarity?
+
+Several techniques are available to assess vector similarity, with some of the most prevalent ones being:
+
+### Euclidean Distance (L2 norm)
+
+**Euclidean Distance (L2 norm)** calculates the linear distance between two points within a multi-dimensional space. Lower values indicate closer proximity, and hence higher similarity.
+
+
+
+For illustration purposes, let's assess `product 1` and `product 2` from the earlier ecommerce dataset and determine the `Euclidean Distance` considering all features.
+
+
+
+As an example, we will use a 2D chart made with [chart.js](https://www.chartjs.org/) comparing the `Price vs. Quality` features of our products, focusing solely on these two attributes to compute the `Euclidean Distance`.
+
+
+
+### Cosine Similarity
+
+**Cosine Similarity** measures the cosine of the angle between two vectors. The cosine similarity value ranges between -1 and 1. A value closer to 1 implies a smaller angle and higher similarity, while a value closer to -1 implies a larger angle and lower similarity. Cosine similarity is particularly popular in NLP when dealing with text vectors.
+
+
+
+:::note
+If two vectors are pointing in the same direction, the cosine of the angle between them is 1. If they're orthogonal, the cosine is 0, and if they're pointing in opposite directions, the cosine is -1.
+:::
+
+Again, consider `product 1` and `product 2` from the previous dataset and calculate the `Cosine Distance` for all features.
+
+
+
+Using [chart.js](https://www.chartjs.org/), we've crafted a 2D chart of `Price vs. Quality` features. It visualizes the `Cosine Similarity` solely based on these attributes.
+
+
+
+### Inner Product
+
+**Inner Product (dot product)** The inner product (or dot product) isn't a distance metric in the traditional sense but can be used to calculate similarity, especially when vectors are normalized (have a magnitude of 1). It's the sum of the products of the corresponding entries of the two sequences of numbers.
+
+
+
+:::note
+The inner product can be thought of as a measure of how much two vectors "align"
+in a given vector space. Higher values indicate higher similarity. However, the raw
+values can be large for long vectors; hence, normalization is recommended for better
+interpretation. If the vectors are normalized, their dot product will be `1 if they are identical` and `0 if they are orthogonal` (uncorrelated).
+:::
+
+Considering our `product 1` and `product 2`, let's compute the `Inner Product` across all features.
+
+
+
+:::tip
+Vectors can also be stored in databases in **binary formats** to save space. In practical applications, it's crucial to strike a balance between the dimensionality of the vectors (which impacts storage and computational costs) and the quality or granularity of the information they capture.
+:::
+
+## Further reading
+
+- [Vector search in Redis 7.2](https://redis.com/blog/introducing-redis-7-2/)
+
+- [Redis VSS getting started](https://github.com/redis-developer/redis-ai-resources/tree/main/python-recipes/vector-search)
+- [Redis vector use cases](https://redis.com/solutions/use-cases/vector-database/)
+- [Vector query docs](https://redis.io/docs/interact/search-and-query/search/vectors/)
diff --git a/docs/howtos/solutions/vector/image-summary-search/images/01-ui-settings.png b/docs/howtos/solutions/vector/image-summary-search/images/01-ui-settings.png
new file mode 100644
index 00000000000..e8460e19d8e
Binary files /dev/null and b/docs/howtos/solutions/vector/image-summary-search/images/01-ui-settings.png differ
diff --git a/docs/howtos/solutions/vector/image-summary-search/images/02-ui-image-search.png b/docs/howtos/solutions/vector/image-summary-search/images/02-ui-image-search.png
new file mode 100644
index 00000000000..82907b0fd46
Binary files /dev/null and b/docs/howtos/solutions/vector/image-summary-search/images/02-ui-image-search.png differ
diff --git a/docs/howtos/solutions/vector/image-summary-search/images/03-ui-toggle-image-summary.jpg b/docs/howtos/solutions/vector/image-summary-search/images/03-ui-toggle-image-summary.jpg
new file mode 100644
index 00000000000..84a384e42ea
Binary files /dev/null and b/docs/howtos/solutions/vector/image-summary-search/images/03-ui-toggle-image-summary.jpg differ
diff --git a/docs/howtos/solutions/vector/image-summary-search/images/product-img.webp b/docs/howtos/solutions/vector/image-summary-search/images/product-img.webp
new file mode 100644
index 00000000000..5c2de3f1498
Binary files /dev/null and b/docs/howtos/solutions/vector/image-summary-search/images/product-img.webp differ
diff --git a/docs/howtos/solutions/vector/image-summary-search/images/redis-insight-ai-image.png b/docs/howtos/solutions/vector/image-summary-search/images/redis-insight-ai-image.png
new file mode 100644
index 00000000000..c665bbb6d35
Binary files /dev/null and b/docs/howtos/solutions/vector/image-summary-search/images/redis-insight-ai-image.png differ
diff --git a/docs/howtos/solutions/vector/image-summary-search/index-image-summary-search.mdx b/docs/howtos/solutions/vector/image-summary-search/index-image-summary-search.mdx
new file mode 100644
index 00000000000..931e4da7078
--- /dev/null
+++ b/docs/howtos/solutions/vector/image-summary-search/index-image-summary-search.mdx
@@ -0,0 +1,458 @@
+---
+id: index-image-summary-search
+title: Semantic Image Based Queries Using LangChain (OpenAI) and Redis
+sidebar_label: Semantic Image Based Queries Using LangChain (OpenAI) and Redis
+slug: /howtos/solutions/vector/image-summary-search
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import InitialMicroservicesArchitecture from '../../microservices/common-data/microservices-arch.mdx';
+import MicroservicesEcommerceAIDesign from '../common-ai/microservices-ecommerce-ai.mdx';
+import sampleProductImage from './images/product-img.webp';
+import SourceCode from '../common-ai/microservices-source-code-ai.mdx';
+
+
+
+## What you will learn in this tutorial
+
+This tutorial demonstrates how to perform semantic search on product images using LangChain (OpenAI) and Redis. Specifically, we'll cover the following topics:
+
+- **E-Commerce Application Context** : Consider a sample e-commerce application scenario where customers can utilize image-based queries for product searches, add items to their shopping cart, and complete purchases, thereby highlighting a real-world application of semantic search.
+
+- **Database setup** : This involves generating descriptive summaries for product images, creating semantic embeddings for generated summaries and efficiently storing them in Redis.
+
+- **Setting up the search API** : This API is designed to process user queries in the context of image content. It integrates the capabilities of OpenAI for semantic analysis with Redis for efficient data retrieval and storage.
+
+## Terminology
+
+**[LangChain](https://js.langchain.com)** is an innovative library for building language model applications. It offers a structured way to combine different components like language models (e.g., OpenAI's models), storage solutions (like Redis), and custom logic. This modular approach facilitates the creation of sophisticated AI applications.
+
+**[OpenAI](https://openai.com/)** provides advanced language models like GPT-3, which have revolutionized the field with their ability to understand and generate human-like text. These models form the backbone of many modern AI applications including semantic text/ image search and chatbots.
+
+## Microservices architecture for an e-commerce application
+
+
+
+
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+## Database setup
+
+:::info
+Sign up for an [OpenAI account](https://platform.openai.com/) to get your API key to be used in the demo (add OPEN_AI_API_KEY variable in .env file). You can also refer to the [OpenAI API documentation](https://platform.openai.com/docs/api-reference/introduction) for more information.
+:::
+
+
+
+### Sample data
+
+In this tutorial, we'll use a simplified e-commerce dataset. Specifically, our JSON structure includes `product` details and a key named `styleImages_default_imageURL`, which links to an image of the product. This image will be the focus of our AI-driven semantic search.
+
+```ts title="database/fashion-dataset/001/products/*.json"
+const products = [
+ {
+ productId: '11000',
+ price: 3995,
+ productDisplayName: 'Puma Men Slick 3HD Yellow Black Watches',
+ variantName: 'Slick 3HD Yellow',
+ brandName: 'Puma',
+ // Additional product details...
+ styleImages_default_imageURL:
+ 'http://host.docker.internal:8080/images/11000.jpg',
+ // Other properties...
+ },
+ // Additional products...
+];
+```
+
+### Generating OpenAI image summary
+
+The following code segment outlines the process of generating a text summary for a product image using OpenAI's capabilities. We'll first convert the image URL to a base64 string using `fetchImageAndConvertToBase64` function and then utilize OpenAI to generate a summary of the image using `getOpenAIImageSummary` function.
+
+```ts title="database/src/open-ai-image.ts"
+import {
+ ChatOpenAI,
+ ChatOpenAICallOptions,
+} from 'langchain/chat_models/openai';
+import { HumanMessage } from 'langchain/schema';
+import { Document } from 'langchain/document';
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
+import { RedisVectorStore } from 'langchain/vectorstores/redis';
+
+let llm: ChatOpenAI;
+
+// Instantiates the LangChain ChatOpenAI instance
+const getOpenAIVisionInstance = (_openAIApiKey: string) => {
+ //OpenAI supports images with text in input messages with their gpt-4-vision-preview.
+ if (!llm) {
+ llm = new ChatOpenAI({
+ openAIApiKey: _openAIApiKey,
+ modelName: 'gpt-4-vision-preview',
+ maxTokens: 1024,
+ });
+ }
+ return llm;
+};
+
+const fetchImageAndConvertToBase64 = async (_imageURL: string) => {
+ let base64Image = '';
+ try {
+ const response = await axios.get(_imageURL, {
+ responseType: 'arraybuffer',
+ });
+ // Convert image to Base64
+ base64Image = Buffer.from(response.data, 'binary').toString('base64');
+ } catch (error) {
+ console.error(
+ `Error fetching or converting the image: ${_imageURL}`,
+ error,
+ );
+ }
+ return base64Image;
+};
+
+// Generates an OpenAI summary for a given base64 image string
+const getOpenAIImageSummary = async (
+ _openAIApiKey: string,
+ _base64Image: string,
+ _product: Prisma.ProductCreateInput,
+) => {
+ /*
+ Reference : https://js.langchain.com/docs/integrations/chat/openai#multimodal-messages
+
+ - This function utilizes OpenAI's multimodal capabilities to generate a summary from the image.
+ - It constructs a prompt that combines the product description with the image.
+ - OpenAI's vision model then processes this prompt to generate a detailed summary.
+
+ */
+ let imageSummary = '';
+
+ try {
+ if (_openAIApiKey && _base64Image && _product) {
+ const llmInst = getOpenAIVisionInstance(_openAIApiKey);
+
+ const text = `Below are the product details and image of an e-commerce product for reference. Please conduct and provide a comprehensive analysis of the product depicted in the image .
+
+ Product Details:
+ ${_product.productDescriptors_description_value}
+
+ Image:
+ `;
+ // Constructing a multimodal message combining text and image
+ const imagePromptMessage = new HumanMessage({
+ content: [
+ {
+ type: 'text',
+ text: text,
+ },
+ {
+ type: 'image_url',
+ image_url: {
+ url: `data:image/jpeg;base64,${_base64Image}`,
+ detail: 'high', // low, high (if you want more detail)
+ },
+ },
+ ],
+ });
+
+ // Invoking the LangChain ChatOpenAI model with the constructed message
+ const response = await llmInst.invoke([imagePromptMessage]);
+ if (response?.content) {
+ imageSummary = response.content;
+ }
+ }
+ } catch (err) {
+ console.log(
+ `Error generating OpenAIImageSummary for product id ${_product.productId}`,
+ err,
+ );
+ }
+ return imageSummary;
+};
+```
+
+### Sample image & OpenAI summary
+
+The following section demonstrates the result of the above process. We'll use the image of a Puma T-shirt and generate a summary using OpenAI's capabilities.
+
+
+
+Comprehensive summary generated by the OpenAI model is as follows:
+
+```txt
+This product is a black round neck T-shirt featuring a design consistent with the Puma brand aesthetic, which includes their iconic leaping cat logo in a contrasting yellow color placed prominently across the chest area. The T-shirt is made from 100% cotton, suggesting it is likely to be breathable and soft to the touch. It has a classic short-sleeve design with a ribbed neckline for added texture and durability. There is also mention of a vented hem, which may offer additional comfort and mobility.
+
+The T-shirt is described to have a 'comfort' fit, which typically means it is designed to be neither too tight nor too loose, allowing for ease of movement without being baggy. This could be ideal for casual wear or active use.
+
+Care instructions are also comprehensive, advising a gentle machine wash with similar colors in cool water at 30 degrees Celsius, indicating it is relatively easy to care for. However, one should avoid bleaching, tumble drying, and dry cleaning it, but a warm iron is permissible.
+
+Looking at the image provided:
+
+- The T-shirt appears to fit the model well, in accordance with the described 'comfort' fit.
+- The color contrast between the T-shirt and the graphic gives the garment a modern, sporty look.
+- The model is paired with denim jeans, showcasing the T-shirt's versatility for casual occasions. However, the product description suggests it can be part of an athletic ensemble when combined with Puma shorts and shoes.
+- Considering the model's statistics, prospective buyers could infer how this T-shirt might fit on a person with similar measurements.
+
+Overall, the T-shirt is positioned as a versatile item suitable for both lifestyle and sporting activities, with a strong brand identity through the graphic, and is likely comfortable and easy to maintain based on the product details provided.
+```
+
+### Seeding Image summary embeddings
+
+The `addImageSummaryEmbeddingsToRedis` function plays a critical role in integrating AI-generated image summaries with Redis. This process involves two main steps:
+
+1. **Generating Vector Documents**: Utilizing the `getImageSummaryVectorDocuments` function, we transform image summaries into vector documents. This transformation is crucial as it converts textual summaries into a format suitable for Redis storage.
+
+1. **Seeding Embeddings into Redis**: The `seedImageSummaryEmbeddings` function is then employed to store these vector documents into Redis. This step is essential for enabling efficient retrieval and search capabilities within the Redis database.
+
+```ts
+// Function to generate vector documents from image summaries
+const getImageSummaryVectorDocuments = async (
+ _products: Prisma.ProductCreateInput[],
+ _openAIApiKey: string,
+) => {
+ const vectorDocs: Document[] = [];
+
+ if (_products?.length > 0) {
+ let count = 1;
+ for (let product of _products) {
+ if (product) {
+ let imageURL = product.styleImages_default_imageURL; //cdn url
+ const imageData = await fetchImageAndConvertToBase64(imageURL);
+ imageSummary = await getOpenAIImageSummary(
+ _openAIApiKey,
+ imageData,
+ product,
+ );
+ console.log(
+ `openAI imageSummary #${count++} generated for product id: ${
+ product.productId
+ }`,
+ );
+
+ if (imageSummary) {
+ let doc = new Document({
+ metadata: {
+ productId: product.productId,
+ imageURL: imageURL,
+ },
+ pageContent: imageSummary,
+ });
+ vectorDocs.push(doc);
+ }
+ }
+ }
+ }
+ return vectorDocs;
+};
+
+// Seeding vector documents into Redis
+const seedImageSummaryEmbeddings = async (
+ vectorDocs: Document[],
+ _redisClient: NodeRedisClientType,
+ _openAIApiKey: string,
+) => {
+ if (vectorDocs?.length && _redisClient && _openAIApiKey) {
+ const embeddings = new OpenAIEmbeddings({
+ openAIApiKey: _openAIApiKey,
+ });
+ const vectorStore = await RedisVectorStore.fromDocuments(
+ vectorDocs,
+ embeddings,
+ {
+ redisClient: _redisClient,
+ indexName: 'openAIProductImgIdx',
+ keyPrefix: 'openAIProductImgText:',
+ },
+ );
+ console.log('seeding imageSummaryEmbeddings completed');
+ }
+};
+
+const addImageSummaryEmbeddingsToRedis = async (
+ _products: Prisma.ProductCreateInput[],
+ _redisClient: NodeRedisClientType,
+ _openAIApiKey: string,
+) => {
+ const vectorDocs = await getImageSummaryVectorDocuments(
+ _products,
+ _openAIApiKey,
+ );
+
+ await seedImageSummaryEmbeddings(vectorDocs, _redisClient, _openAIApiKey);
+};
+```
+
+The image below shows the JSON structure of **openAI image summary** within RedisInsight.
+
+
+:::tip
+
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to visually explore your Redis data or to engage with raw Redis commands in the workbench.
+
+:::
+
+## Setting up the search API
+
+### API end point
+
+This section covers the API request and response structure for `getProductsByVSSImageSummary`, which is essential for retrieving products based on semantic search using image summaries.
+
+**Request Format**
+
+The example request format for the API is as follows:
+
+```json
+POST http://localhost:3000/products/getProductsByVSSImageSummary
+{
+ "searchText":"Left chest nike logo",
+
+ //optional
+ "maxProductCount": 4, // 2 (default)
+ "similarityScoreLimit":0.2, // 0.2 (default)
+}
+```
+
+**Response Structure**
+
+The response from the API is a JSON object containing an array of product details that match the semantic search criteria:
+
+```json
+{
+ "data": [
+ {
+ "productId": "10017",
+ "price": 3995,
+ "productDisplayName": "Nike Women As The Windru Blue Jackets",
+ "brandName": "Nike",
+ "styleImages_default_imageURL": "http://host.docker.internal:8080/products/01/10017/product-img.webp",
+ "productDescriptors_description_value": " Blue and White jacket made of 100% polyester, with an interior pocket ...",
+ "stockQty": 25,
+ "similarityScore": 0.163541972637,
+ "imageSummary": "The product in the image is a blue and white jacket featuring a design consistent with the provided description. ..."
+ }
+ // Additional products...
+ ],
+ "error": null,
+ "auth": "SES_fd57d7f4-3deb-418f-9a95-6749cd06e348"
+}
+```
+
+### API implementation
+
+The backend implementation of this API involves following steps:
+
+1. `getProductsByVSSImageSummary` function handles the API Request.
+1. `getSimilarProductsScoreByVSSImageSummary` function performs semantic search on image summaries. It integrates with `OpenAI's` semantic analysis capabilities to interpret the searchText and identify relevant products from `Redis` vector store.
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+const getSimilarProductsScoreByVSSImageSummary = async (
+ _params: IParamsGetProductsByVSS,
+) => {
+ let {
+ standAloneQuestion,
+ openAIApiKey,
+
+ //optional
+ KNN,
+ scoreLimit,
+ } = _params;
+
+ let vectorDocs: Document[] = [];
+ const client = getNodeRedisClient();
+
+ KNN = KNN || 2;
+ scoreLimit = scoreLimit || 1;
+
+ const embeddings = new OpenAIEmbeddings({
+ openAIApiKey: openAIApiKey,
+ });
+
+ // create vector store
+ const vectorStore = new RedisVectorStore(embeddings, {
+ redisClient: client,
+ indexName: 'openAIProductImgIdx',
+ keyPrefix: 'openAIProductImgText:',
+ });
+
+ // search for similar products
+ const vectorDocsWithScore = await vectorStore.similaritySearchWithScore(
+ standAloneQuestion,
+ KNN,
+ );
+
+ // filter by scoreLimit
+ for (let [doc, score] of vectorDocsWithScore) {
+ if (score <= scoreLimit) {
+ doc['similarityScore'] = score;
+ vectorDocs.push(doc);
+ }
+ }
+
+ return vectorDocs;
+};
+```
+
+```ts title="server/src/services/products/src/service-impl.ts"
+const getProductsByVSSImageSummary = async (
+ productsVSSFilter: IProductsVSSBodyFilter,
+) => {
+ let { searchText, maxProductCount, similarityScoreLimit } = productsVSSFilter;
+ let products: IProduct[] = [];
+
+ const openAIApiKey = process.env.OPEN_AI_API_KEY || '';
+ maxProductCount = maxProductCount || 2;
+ similarityScoreLimit = similarityScoreLimit || 0.2;
+
+ //VSS search
+ const vectorDocs = await getSimilarProductsScoreByVSSImageSummary({
+ standAloneQuestion: searchText,
+ openAIApiKey: openAIApiKey,
+ KNN: maxProductCount,
+ scoreLimit: similarityScoreLimit,
+ });
+
+ if (vectorDocs?.length) {
+ const productIds = vectorDocs.map((doc) => doc?.metadata?.productId);
+
+ //get product with details
+ products = await getProductByIds(productIds, true);
+ }
+
+ //...
+
+ return products;
+};
+```
+
+### Frontend UI
+
+- **Settings configuration**: Initially, ensure that the `Semantic image summary search` option is enabled in the settings page.
+ 
+
+- **Performing a search**: On the dashboard page, users can conduct searches using image-based queries. For example, if the query is `Left chest nike logo`, the search results will display products like a Nike jacket, characterized by a logo on its left chest, reflecting the query.
+
+ 
+
+- **Viewing image summaries**: Users can click on any product image to view the corresponding image summary generated by OpenAI. This feature offers an insightful glimpse into how AI interprets and summarizes visual content.
+ 
+
+## Ready to use Redis for semantic image based queries?
+
+Performing semantic search on image summaries is a powerful tool for e-commerce applications. It allows users to search for products based on their descriptions or images, enabling a more intuitive and efficient shopping experience. This tutorial has demonstrated how to integrate OpenAI's semantic analysis capabilities with Redis to create a robust search engine for e-commerce applications.
+
+## Further reading
+
+- [Perform vector similarity search using Redis](/howtos/solutions/vector/getting-started-vector)
+
+- [LangChain JS](https://js.langchain.com/docs/get_started/quickstart)
+ - [Learn LangChain](https://scrimba.com/learn/langchain)
+- [LangChain redis integration](https://js.langchain.com/docs/integrations/vectorstores/redis)
diff --git a/docs/howtos/solutions/vector/semantic-text-search/images/01-ui-settings2.png b/docs/howtos/solutions/vector/semantic-text-search/images/01-ui-settings2.png
new file mode 100644
index 00000000000..927cbe19337
Binary files /dev/null and b/docs/howtos/solutions/vector/semantic-text-search/images/01-ui-settings2.png differ
diff --git a/docs/howtos/solutions/vector/semantic-text-search/images/02-ui-image-search2.png b/docs/howtos/solutions/vector/semantic-text-search/images/02-ui-image-search2.png
new file mode 100644
index 00000000000..6e0bc20e139
Binary files /dev/null and b/docs/howtos/solutions/vector/semantic-text-search/images/02-ui-image-search2.png differ
diff --git a/docs/howtos/solutions/vector/semantic-text-search/images/redis-insight-ai-product-details.png b/docs/howtos/solutions/vector/semantic-text-search/images/redis-insight-ai-product-details.png
new file mode 100644
index 00000000000..51cd041a39f
Binary files /dev/null and b/docs/howtos/solutions/vector/semantic-text-search/images/redis-insight-ai-product-details.png differ
diff --git a/docs/howtos/solutions/vector/semantic-text-search/index-semantic-text-search.mdx b/docs/howtos/solutions/vector/semantic-text-search/index-semantic-text-search.mdx
new file mode 100644
index 00000000000..9cb55b3f264
--- /dev/null
+++ b/docs/howtos/solutions/vector/semantic-text-search/index-semantic-text-search.mdx
@@ -0,0 +1,340 @@
+---
+id: index-semantic-text-search
+title: Semantic Text Search Using LangChain (OpenAI) and Redis
+sidebar_label: Semantic Text Search Using LangChain (OpenAI) and Redis
+slug: /howtos/solutions/vector/semantic-text-search
+authors: [prasan, will]
+---
+
+import Authors from '@theme/Authors';
+import InitialMicroservicesArchitecture from '../../microservices/common-data/microservices-arch.mdx';
+import MicroservicesEcommerceAIDesign from '../common-ai/microservices-ecommerce-ai.mdx';
+import SourceCode from '../common-ai/microservices-source-code-ai.mdx';
+
+
+
+## What you will learn in this tutorial
+
+This tutorial explores the implementation of semantic text search in product descriptions using LangChain (OpenAI) and Redis. The focus areas include:
+
+- **Contextualizing E-Commerce**: Dive into an e-commerce scenario where semantic text search empowers users to find products through detailed textual queries.
+- **Database Implementation**: Learn to create and store semantic embeddings from product descriptions in Redis for efficient search capabilities.
+- **Search API Development**: Understand how to build an API that leverages OpenAI for semantic analysis of text and Redis for data management.
+
+## Terminology
+
+- **[LangChain](https://js.langchain.com)**: A versatile library for developing language model applications, combining language models, storage systems, and custom logic.
+- **[OpenAI](https://openai.com/)**: A provider of cutting-edge language models like GPT-3, essential for applications in semantic search and conversational AI.
+
+## Microservices architecture for an e-commerce application
+
+
+
+
+
+## E-commerce application frontend using Next.js and Tailwind
+
+
+
+## Database setup
+
+:::info
+Sign up for an [OpenAI account](https://platform.openai.com/) to get your API key to be used in the demo (add OPEN_AI_API_KEY variable in .env file). You can also refer to the [OpenAI API documentation](https://platform.openai.com/docs/api-reference/introduction) for more information.
+:::
+
+
+
+### Sample data
+
+Consider a simplified e-commerce dataset featuring product details for semantic search.
+
+```ts title="database/fashion-dataset/001/products/*.json"
+const products = [
+ {
+ productId: '11000',
+ price: 3995,
+ productDisplayName: 'Puma Men Slick 3HD Yellow Black Watches',
+ variantName: 'Slick 3HD Yellow',
+ brandName: 'Puma',
+ ageGroup: 'Adults-Men',
+ gender: 'Men',
+ displayCategories: 'Accessories',
+ masterCategory_typeName: 'Accessories',
+ subCategory_typeName: 'Watches',
+ styleImages_default_imageURL:
+ 'http://host.docker.internal:8080/images/11000.jpg',
+ productDescriptors_description_value: 'Stylish and comfortable, ...',
+ stockQty: 25,
+ },
+ //...
+];
+```
+
+### Seeding product details embeddings
+
+Implement the `addEmbeddingsToRedis` function to integrate AI-generated product description embeddings with Redis.
+
+This process involves two main steps:
+
+1. **Generating Vector Documents**: Utilizing the `convertToVectorDocuments` function, we transform product details into vector documents. This transformation is crucial as it converts product details into a format suitable for Redis storage.
+
+1. **Seeding Embeddings into Redis**: The `seedOpenAIEmbeddings` function is then employed to store these vector documents into Redis. This step is essential for enabling efficient retrieval and search capabilities within the Redis database.
+
+```ts
+import { Document } from 'langchain/document';
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
+import { RedisVectorStore } from 'langchain/vectorstores/redis';
+
+const convertToVectorDocuments = async (
+ _products: Prisma.ProductCreateInput[],
+) => {
+ const vectorDocs: Document[] = [];
+
+ if (_products?.length > 0) {
+ for (let product of _products) {
+ let doc = new Document({
+ metadata: {
+ productId: product.productId,
+ },
+ pageContent: ` Product details are as follows:
+ productId: ${product.productId}.
+
+ productDisplayName: ${product.productDisplayName}.
+
+ price: ${product.price}.
+
+ variantName: ${product.variantName}.
+
+ brandName: ${product.brandName}.
+
+ ageGroup: ${product.ageGroup}.
+
+ gender: ${product.gender}.
+
+ productColors: ${product.productColors}
+
+ Category: ${product.displayCategories}, ${product.masterCategory_typeName} - ${product.subCategory_typeName}
+
+ productDescription: ${product.productDescriptors_description_value}`,
+ });
+
+ vectorDocs.push(doc);
+ }
+ }
+ return vectorDocs;
+};
+
+const seedOpenAIEmbeddings = async (
+ vectorDocs: Document[],
+ _redisClient: NodeRedisClientType,
+ _openAIApiKey: string,
+) => {
+ if (vectorDocs?.length && _redisClient && _openAIApiKey) {
+ console.log('openAIEmbeddings started !');
+
+ const embeddings = new OpenAIEmbeddings({
+ openAIApiKey: _openAIApiKey,
+ });
+ const vectorStore = await RedisVectorStore.fromDocuments(
+ vectorDocs,
+ embeddings,
+ {
+ redisClient: _redisClient,
+ indexName: 'openAIProductsIdx',
+ keyPrefix: 'openAIProducts:',
+ },
+ );
+ console.log('OpenAIEmbeddings completed');
+ }
+};
+
+const addEmbeddingsToRedis = async (
+ _products: Prisma.ProductCreateInput[],
+ _redisClient: NodeRedisClientType,
+ _openAIApiKey: string,
+ _huggingFaceApiKey?: string,
+) => {
+ if (_products?.length > 0 && _redisClient && _openAIApiKey) {
+ const vectorDocs = await convertToVectorDocuments(_products);
+
+ await seedOpenAIEmbeddings(vectorDocs, _redisClient, _openAIApiKey);
+ }
+};
+```
+
+Examine the structured `openAI product details` within Redis using RedisInsight.
+
+
+
+:::tip
+
+Download [RedisInsight](https://redis.com/redis-enterprise/redis-insight/) to visually explore your Redis data or to engage with raw Redis commands in the workbench.
+
+:::
+
+## Setting up the search API
+
+### API end point
+
+This section covers the API request and response structure for `getProductsByVSSText`, which is essential for retrieving products based on semantic text search.
+
+**Request Format**
+
+The example request format for the API is as follows:
+
+```json
+POST http://localhost:3000/products/getProductsByVSSText
+{
+ "searchText":"pure cotton blue shirts",
+
+ //optional
+ "maxProductCount": 4, // 2 (default)
+ "similarityScoreLimit":0.2, // 0.2 (default)
+}
+```
+
+**Response Structure**
+
+The response from the API is a JSON object containing an array of product details that match the semantic search criteria:
+
+```json
+{
+ "data": [
+ {
+ "productId": "11031",
+ "price": 1099,
+ "productDisplayName": "Jealous 21 Women Check Blue Tops",
+ "productDescriptors_description_value": "Composition : Green and navy blue checked round neck blouson tunic top made of 100% cotton, has a full buttoned placket, three fourth sleeves with buttoned cuffs and a belt below the waist
Fitting
Regular
Wash care
Machine/hand wash separately in mild detergent
Do not bleach or wring
Dry in shade
Medium iron
If you're in the mood to have some checked fun, this blouson tunic top from jealous 21 will fulfil your heart's desire with élan. The cotton fabric promises comfort, while the smart checks guarantee unparalleled attention. Pair this top with leggings and ballerinas for a cute, neat look.
Model statistics
The model wears size M in tops
Height: 5'7\"; Chest: 33\"; Waist: 25\"
",
+ "stockQty": 25,
+ "productColors": "Blue,Green",
+ "similarityScore": 0.168704152107
+ //...
+ }
+ ],
+ "error": null,
+ "auth": "SES_fd57d7f4-3deb-418f-9a95-6749cd06e348"
+}
+```
+
+### API implementation
+
+The backend implementation of this API involves following steps:
+
+1. `getProductsByVSSText` function handles the API Request.
+1. `getSimilarProductsScoreByVSS` function performs semantic search on product details. It integrates with `OpenAI's` semantic analysis capabilities to interpret the searchText and identify relevant products from `Redis` vector store.
+
+```ts title="server/src/services/products/src/open-ai-prompt.ts"
+const getSimilarProductsScoreByVSS = async (
+ _params: IParamsGetProductsByVSS,
+) => {
+ let {
+ standAloneQuestion,
+ openAIApiKey,
+
+ //optional
+ KNN,
+ scoreLimit,
+ } = _params;
+
+ let vectorDocs: Document[] = [];
+ const client = getNodeRedisClient();
+
+ KNN = KNN || 2;
+ scoreLimit = scoreLimit || 1;
+
+ let embeddings = new OpenAIEmbeddings({
+ openAIApiKey: openAIApiKey,
+ });
+ let indexName = 'openAIProductsIdx';
+ let keyPrefix = 'openAIProducts:';
+
+ if (embeddings) {
+ // create vector store
+ const vectorStore = new RedisVectorStore(embeddings, {
+ redisClient: client,
+ indexName: indexName,
+ keyPrefix: keyPrefix,
+ });
+
+ // search for similar products
+ const vectorDocsWithScore = await vectorStore.similaritySearchWithScore(
+ standAloneQuestion,
+ KNN,
+ );
+
+ // filter by scoreLimit
+ for (let [doc, score] of vectorDocsWithScore) {
+ if (score <= scoreLimit) {
+ doc['similarityScore'] = score;
+ vectorDocs.push(doc);
+ }
+ }
+ }
+
+ return vectorDocs;
+};
+```
+
+```ts title="server/src/services/products/src/service-impl.ts"
+const getProductsByVSSText = async (
+ productsVSSFilter: IProductsVSSBodyFilter,
+) => {
+ let { searchText, maxProductCount, similarityScoreLimit } = productsVSSFilter;
+ let products: IProduct[] = [];
+
+ const openAIApiKey = process.env.OPEN_AI_API_KEY || '';
+ maxProductCount = maxProductCount || 2;
+ similarityScoreLimit = similarityScoreLimit || 0.2;
+
+ if (!openAIApiKey) {
+ throw new Error('Please provide openAI API key in .env file');
+ }
+
+ if (!searchText) {
+ throw new Error('Please provide search text');
+ }
+
+ //VSS search
+ const vectorDocs = await getSimilarProductsScoreByVSS({
+ standAloneQuestion: searchText,
+ openAIApiKey: openAIApiKey,
+ KNN: maxProductCount,
+ scoreLimit: similarityScoreLimit,
+ });
+
+ if (vectorDocs?.length) {
+ const productIds = vectorDocs.map((doc) => doc?.metadata?.productId);
+
+ //get product with details
+ products = await getProductByIds(productIds, true);
+ }
+
+ //...
+
+ return products;
+};
+```
+
+### Frontend UI
+
+- **Settings configuration**: Enable `Semantic text search` in the settings page
+ 
+
+- **Performing a search**: Use textual queries on the dashboard.
+ 
+
+- Note: Users can click on the product description within the product card
+ to view the complete details.
+
+## Ready to use Redis for semantic text search?
+
+Discover the power of semantic text search for enhancing the e-commerce experience. This tutorial guides you through integrating OpenAI's semantic capabilities with Redis for a dynamic product search engine.
+
+## Further reading
+
+- [Perform vector similarity search using Redis](/howtos/solutions/vector/getting-started-vector)
+- [Semantic Image Based Queries Using LangChain (OpenAI) and Redis](/howtos/solutions/vector/image-summary-search)
+
+- [LangChain JS](https://js.langchain.com/docs/get_started/quickstart)
+ - [Learn LangChain](https://scrimba.com/learn/langchain)
+- [LangChain redis integration](https://js.langchain.com/docs/integrations/vectorstores/redis)
diff --git a/docs/howtos/solutions/vector/video-qa/images/ask-question.png b/docs/howtos/solutions/vector/video-qa/images/ask-question.png
new file mode 100644
index 00000000000..a1e0ad2a692
Binary files /dev/null and b/docs/howtos/solutions/vector/video-qa/images/ask-question.png differ
diff --git a/docs/howtos/solutions/vector/video-qa/images/redisinsight-keys.png b/docs/howtos/solutions/vector/video-qa/images/redisinsight-keys.png
new file mode 100644
index 00000000000..8753a66dcfb
Binary files /dev/null and b/docs/howtos/solutions/vector/video-qa/images/redisinsight-keys.png differ
diff --git a/docs/howtos/solutions/vector/video-qa/images/upload-videos.png b/docs/howtos/solutions/vector/video-qa/images/upload-videos.png
new file mode 100644
index 00000000000..44694350934
Binary files /dev/null and b/docs/howtos/solutions/vector/video-qa/images/upload-videos.png differ
diff --git a/docs/howtos/solutions/vector/video-qa/images/video-qa-existing-answer.png b/docs/howtos/solutions/vector/video-qa/images/video-qa-existing-answer.png
new file mode 100644
index 00000000000..29f3375352e
Binary files /dev/null and b/docs/howtos/solutions/vector/video-qa/images/video-qa-existing-answer.png differ
diff --git a/docs/howtos/solutions/vector/video-qa/images/video-qa-supporting-videos.png b/docs/howtos/solutions/vector/video-qa/images/video-qa-supporting-videos.png
new file mode 100644
index 00000000000..cc1161e5c6b
Binary files /dev/null and b/docs/howtos/solutions/vector/video-qa/images/video-qa-supporting-videos.png differ
diff --git a/docs/howtos/solutions/vector/video-qa/index-video-qa.mdx b/docs/howtos/solutions/vector/video-qa/index-video-qa.mdx
new file mode 100644
index 00000000000..e86854eeaac
--- /dev/null
+++ b/docs/howtos/solutions/vector/video-qa/index-video-qa.mdx
@@ -0,0 +1,849 @@
+---
+id: index-video-qa
+title: Building an AI-Powered Video Q&A Application with Redis and LangChain
+sidebar_label: Building an AI-Powered Video Q&A Application with Redis and LangChain
+slug: /howtos/solutions/vector/ai-qa-videos-langchain-redis-openai-google
+authors: [will, prasan]
+---
+
+import Authors from '@theme/Authors';
+
+
+
+## What you will learn in this tutorial
+
+This tutorial focuses on building a Q&A answer engine for video content. It will cover the following topics:
+
+1. How to use `OpenAI`, `Google Gemini`, and `LangChain` to summarize video content and generate vector embeddings
+1. How to use `Redis` to store and search vector embeddings
+1. How to use `Redis` as a semantic vector search cache
+
+:::tip GITHUB CODE
+
+Below is a command to the clone the source code for the application used in this tutorial
+
+```bash
+git clone https://github.com/redis-developer/video-qa-semantic-vector-caching
+```
+
+:::
+
+## Introduction
+
+Before we dive into the details of this tutorial, let's go over a few concepts that are important to understand when building generative AI applications.
+
+1. **Generative AI** is a rapidly evolving field that focuses on creating content, whether it's text, images, or even video. It leverages deep learning techniques to generate new, unique outputs based on learned patterns and data.
+1. **Retrieval-Augmented Generation (RAG)** combines generative models with external knowledge sources to provide more accurate and informed responses. This technique is particularly useful in applications where context-specific information is critical.
+1. [**LangChain**](https://www.langchain.com/) is a powerful library that facilitates the development of applications involving language models. It simplifies tasks such as summarization, question answering, and interaction with generative models like ChatGPT or Google Gemini.
+1. **Google Gemini** and **OpenAI/ChatGPT** are generative models that can be used to generate text based on a given prompt. They are useful for applications that require a large amount of text generation, such as summarization or question answering.
+1. **Semantic vector search** is a technique that uses vector embeddings to find similar items in a database. It is typically combined with RAG to provide more accurate responses to user queries.
+1. **Redis** is an in-memory database that can be used to store and search vector embeddings. It is particularly useful for applications that require fast, real-time responses.
+
+Our application leverages these technologies to create a unique Q&A platform based on video content. Users can upload YouTube video URLs or IDs, and the application utilizes generative AI to summarize these videos, formulate potential questions, and create a searchable database. This database can then be queried to find answers to user-submitted questions, drawing directly from the video content.
+
+## High-level overview of the AI video Q&A application with Redis
+
+Here's how our application uses AI and semantic vector search to answer user questions based on video content:
+
+1. **Uploading videos**: Users can upload YouTube videos either via links (e.g. `https://www.youtube.com/watch?v=LaiQFZ5bXaM`) or video IDs (e.g. `LaiQFZ5bXaM`). The application processes these inputs to retrieve necessary video information. For the purposes of this tutorial, the app is pre-seeded with a collection of videos from the [Redis YouTube channel](https://www.youtube.com/@Redisinc). However, when you run the application you can adjust it to cover your own set of videos.
+
+.
+
+2. **Video processing and AI interaction**: Using the [Youtube Data API](https://developers.google.com/youtube/v3), the application obtains video `titles`, `descriptions`, and `thumbnails`. It also uses [SearchAPI.io](https://searchapi.io) to retrieve video transcripts. These transcripts are then passed to a large language model (LLM) - either Google Gemini or OpenAI's ChatGPT - for summarization and sample question generation. The LLM also generates vector embeddings for these summaries.
+
+An example summary and sample questions generated by the LLM are shown below:
+
+```text title="https://www.youtube.com/watch?v=LaiQFZ5bXaM"
+Summary:
+The video provides a walkthrough of building a real-time stock tracking application
+using Redis Stack, demonstrating its capability to handle multiple data models and
+act as a message broker in a single integrated database. The application maintains
+a watch list of stock symbols, along with real-time trading information and a chart
+updated with live data from the Alpaca API. The presenter uses Redis Stack features
+such as sets, JSON documents, time series, Pub/Sub, and Top-K filter to store and
+manage different types of data. An architecture diagram is provided, explaining the
+interconnection between the front end, API service, and streaming service within
+the application. Code snippets highlight key aspects of the API and streaming
+service written in Python, highlighting the use of Redis Bloom, Redis JSON, Redis
+Time Series, and Redis Search for managing data. The video concludes with a
+demonstration of how data structures are visualized and managed in RedisInsight,
+emphasizing how Redis Stack can simplify the building of a complex real-time
+application by replacing multiple traditional technologies with one solution.
+
+Example Questions and Answers:
+
+Q1: What is Redis Stack and what role does it play in the application?
+Q2: How is the stock watch list stored and managed within the application?
+Q3: What type of data does the application store using time series capabilities of
+Redis Stack?
+Q4: Can you explain the use of the Top-K filter in the application?
+Q5: What methods are used to update the front end with real-time information in
+the application?
+Q6: How does the application sync the watch list with the streaming service?
+Q7: What frontend technologies are mentioned for building the UI of the application?
+Q8: How does Redis Insight help in managing the application data?
+```
+
+3. **Data storage with Redis**: All generated data, including video summaries, potential questions, and vector embeddings, are stored in Redis. The app utilizes Redis's diverse data types for efficient data handling, caching, and quick retrieval.
+
+
+
+4. **Search and answer retrieval**: The frontend, built with Next.js, allows users to ask questions. The application then searches the Redis database using semantic vector similarity to find relevant video content. It further uses the LLM to formulate answers, prioritizing information from video transcripts.
+
+
+
+5. **Presentation of results**: The app displays the most relevant videos along with the AI-generated answers, offering a comprehensive and interactive user experience. It also displays cached results from previous queries using semantic vector caching for faster response times.
+
+
+
+## Setting Up the Environment
+
+To get started with our AI-powered video Q&A application, you'll first need to set up your development environment. We'll follow the instructions outlined in the project's `README.md` file.
+
+### Requirements
+
+- [Node.js](https://nodejs.org/)
+- [Docker](https://www.docker.com/)
+- [SearchAPI.io API Key](https://www.searchapi.io/)
+ - This is used to retrieve video transcripts and free for up to 100 requests. The application will cache the results to help avoid exceeding the free tier.
+- [Google API Key](https://console.cloud.google.com/apis/credentials)
+ - You must have the following APIs enabled:
+ - YouTube Data API v3
+ - Generative Language API
+ - This is used to retrieve video information and prompt the Google Gemini model. This is not free.
+- [OpenAI API Key](https://platform.openai.com/api-keys)
+ - This is used to prompt the OpenAI ChatGPT model. This is not free.
+
+### Setting Up Redis
+
+Redis is used as our database to store and retrieve data efficiently. You can start quickly with a cloud-hosted Redis instance by signing up at [redis.com/try-free](https://redis.com/try-free). This is ideal for both development and testing purposes. You can easily store the data for this application within the limitations of the Redis free tier.
+
+### Cloning the Repository
+
+First, clone the repository containing our project:
+
+```bash
+git clone https://github.com/redis-developer/video-qa-semantic-vector-caching
+```
+
+### Installing Dependencies
+
+After setting up your Node.js environment, you'll need to install the necessary packages. Navigate to the root of your project directory and run the following command:
+
+```bash
+npm install
+```
+
+This command will install all the dependencies listed in the `package.json` file, ensuring you have everything needed to run the application.
+
+### Configuration
+
+Before running the application, make sure to configure the environment variables. There is a script to automatically generate the `.env` files for you. Run the following command:
+
+```bash
+npm run setup
+```
+
+This will generate the following files:
+
+1. `app/.env` - This file contains the environment variables for the Next.js application.
+1. `app/.env.docker` - This file contains overrides for the environment variables when running in Docker.
+1. `services/video-search/.env` - This file contains the environment variables for the video search service.
+1. `services/video-search/.env.docker` - This file contains overrides for the environment variables when running in Docker.
+
+By default, you should not need to touch the environment files in the `app`. However, you will need to configure the environment files in the `services/video-search` directory.
+
+The `services/video-search/.env` looks like this:
+
+```bash
+USE=
+
+REDIS_URL=
+SEARCHAPI_API_KEY=
+YOUTUBE_TRANSCRIPT_PREFIX=
+YOUTUBE_VIDEO_INFO_PREFIX=
+
+GOOGLE_API_KEY=
+GOOGLE_EMBEDDING_MODEL=
+GOOGLE_SUMMARY_MODEL=
+
+OPENAI_API_KEY=
+OPENAI_ORGANIZATION=
+OPENAI_EMBEDDING_MODEL=
+OPENAI_SUMMARY_MODEL=
+```
+
+For Gemini models, you can use the following if you are not sure what to do:
+
+```bash
+GOOGLE_EMBEDDING_MODEL=embedding-001
+GOOGLE_SUMMARY_MODEL=gemini-pro
+```
+
+For OpenAI models, you can use the following if you are not sure what to do:
+
+```bash
+OPENAI_EMBEDDING_MODEL=text-embedding-ada-002
+OPENAI_SUMMARY_MODEL=gpt-4-1106-preview
+```
+
+> NOTE: Depending on your OpenAI tier you may have to use a different summary model. `gpt-3.5` models will be okay.
+
+The `_PREFIX` environment variables are used to prefix the keys in Redis. This is useful if you want to use the same Redis instance for multiple applications. THey have the following defaults:
+
+```bash
+YOUTUBE_TRANSCRIPT_PREFIX=transcripts:
+YOUTUBE_VIDEO_INFO_PREFIX=yt-videos:
+```
+
+If you're satisfied with the defaults, you can delete these values from the `.env` file.
+
+Lastly, the `services/video-search/.env.docker` file contains overrides for the Redis URL when used in Docker. By default this app sets up a local Redis instance in Docker. If you are using a cloud instance, you can simply add the URL to your `.env` and delete the override in the `.env.docker` file.
+
+## Running the application
+
+After installing and configuring the application, run the following command to build the Docker images and run containers:
+
+```bash
+npm run dev
+```
+
+This command builds the app and the video service, and deploys them to Docker. It is all setup for hot reloading, so if you make changes to the code, it will automatically restart the servers.
+
+Once the containers are up and running, the application will be accessible via your web browser:
+
+- **Client**: Available at [http://localhost](http://localhost) (Port 80).
+- **Video search service**: Accessible at [http://localhost:8000](http://localhost:8000/api/healthcheck).
+
+This setup allows you to interact with the client-side application through your browser and make requests to the video search service hosted on a separate port.
+
+The video search service doesn't publish a client application. Instead, it exposes a REST API that can be used to interact with the service. You can validate that it is running by checking Docker or by visiting the following URL:
+
+- [http://localhost:8000/api/healthcheck](http://localhost:8000/api/healthcheck)
+
+You should be up and running now! The rest of this tutorial is focused on how the application works and how to use it, with code examples.
+
+## How to build a video Q&A application with Redis and LangChain
+
+### Video uploading and processing
+
+#### Handling video uploads and retrieving video transcripts and metadata
+
+The backend is set up to handle YouTube video links or IDs. The relevant code snippet from the project demonstrates how these inputs are processed.
+
+```typescript title="services/video-search/src/transcripts/load.ts"
+export type VideoDocument = Document<{
+ id: string;
+ link: string;
+ title: string;
+ description: string;
+ thumbnail: string;
+}>;
+
+export async function load(videos: string[] = config.youtube.VIDEOS) {
+ // Parse the video URLs to get a list of video IDs
+ const videosToLoad: string[] = videos.map(parseVideoUrl).filter((video) => {
+ return typeof video === 'string';
+ }) as string[];
+
+ // Get video title, description, and thumbnail from YouTube API v3
+ const videoInfo = await getVideoInfo(videosToLoad);
+
+ // Get video transcripts from SearchAPI.io, join the video info
+ const transcripts = await mapAsyncInOrder(videosToLoad, async (video) => {
+ return await getTranscript(video, videoInfo[video]);
+ });
+
+ // Return the videos as documents with metadata, and pageContent being the transcript
+ return transcripts.filter(
+ (transcript) => typeof transcript !== 'undefined',
+ ) as VideoDocument[];
+}
+```
+
+In the same file you will see two caches:
+
+```typescript title="services/video-search/src/transcripts/load.ts"
+const cache = cacheAside(config.youtube.TRANSCRIPT_PREFIX);
+const videoCache = jsonCacheAside(config.youtube.VIDEO_INFO_PREFIX);
+```
+
+These caches are used to store the transcripts (as a `string`) and video metadata (as `JSON`) in Redis. The `cache` functions are helper functions that use Redis to store and retrieve data. They looks like this:
+
+```typescript title="services/video-search/src/db.ts"
+export function cacheAside(prefix: string) {
+ return {
+ get: async (key: string) => {
+ return await client.get(`${prefix}${key}`);
+ },
+ set: async (key: string, value: string) => {
+ return await client.set(`${prefix}${key}`, value);
+ },
+ };
+}
+
+export function jsonCacheAside(prefix: string) {
+ return {
+ get: async (key: string): Promise => {
+ return client.json.get(`${prefix}${key}`) as T;
+ },
+ set: async (key: string, value: RedisJSON) => {
+ return await client.json.set(`${prefix}${key}`, '$', value);
+ },
+ };
+}
+```
+
+You will see these functions used elsewhere in the app. They are used to prevent unnecessary API calls, in this case to SearchAPI.io and the YouTube API.
+
+#### Summarizing video content with LangChain, Redis, Google Gemini, and OpenAI ChatGPT
+
+After obtaining the video transcripts and metadata, the transcripts are then summarized using LangChain and the LLMs, both Gemini and ChatGPT. There are a few interesting pieces of code to understand here:
+
+1. The `prompt` used to ask the LLM to summarize the video transcript and generate sample questions
+1. The `refinement chain` used to obtain the summarized video and sample questions
+1. The `vector embedding chain` that uses the LLM to generate text embeddings and store them in Redis
+
+The LLM `summary prompt` is split into two parts. This is done to allow analyzing videos where the transcript length is larger than the LLM's accepted context.
+
+```typescript title="services/video-search/src/api/templates/video.ts"
+import { PromptTemplate } from 'langchain/prompts';
+
+const summaryTemplate = `
+You are an expert in summarizing YouTube videos.
+Your goal is to create a summary of a video.
+Below you find the transcript of a video:
+--------
+{text}
+--------
+
+The transcript of the video will also be used as the basis for a question and answer bot.
+Provide some examples questions and answers that could be asked about the video. Make these questions very specific.
+
+Total output will be a summary of the video and a list of example questions the user could ask of the video.
+
+SUMMARY AND QUESTIONS:
+`;
+
+export const SUMMARY_PROMPT = PromptTemplate.fromTemplate(summaryTemplate);
+
+const summaryRefineTemplate = `
+You are an expert in summarizing YouTube videos.
+Your goal is to create a summary of a video.
+We have provided an existing summary up to a certain point: {existing_answer}
+
+Below you find the transcript of a video:
+--------
+{text}
+--------
+
+Given the new context, refine the summary and example questions.
+The transcript of the video will also be used as the basis for a question and answer bot.
+Provide some examples questions and answers that could be asked about the video. Make
+these questions very specific.
+If the context isn't useful, return the original summary and questions.
+Total output will be a summary of the video and a list of example questions the user could ask of the video.
+
+SUMMARY AND QUESTIONS:
+`;
+
+export const SUMMARY_REFINE_PROMPT = PromptTemplate.fromTemplate(
+ summaryRefineTemplate,
+);
+```
+
+The `summary prompts` are used to create a `refinement chain` with LangChain. LangChain will automatically handle splitting the video transcript document(s) and calling the LLM accordingly.
+
+```typescript title="services/video-search/src/api/prompt.ts" {1-5,30-35}
+const videoSummarizeChain = loadSummarizationChain(llm, {
+ type: 'refine',
+ questionPrompt: SUMMARY_PROMPT,
+ refinePrompt: SUMMARY_REFINE_PROMPT,
+});
+
+const summaryCache = cacheAside(`${prefix}-${config.redis.SUMMARY_PREFIX}`);
+
+async function summarizeVideos(videos: VideoDocument[]) {
+ const summarizedDocs: VideoDocument[] = [];
+
+ for (const video of videos) {
+ log.debug(`Summarizing ${video.metadata.link}`, {
+ ...video.metadata,
+ location: `${prefix}.summarize.docs`,
+ });
+ const existingSummary = await summaryCache.get(video.metadata.id);
+
+ if (typeof existingSummary === 'string') {
+ summarizedDocs.push(
+ new Document({
+ metadata: video.metadata,
+ pageContent: existingSummary,
+ }),
+ );
+
+ continue;
+ }
+
+ const splitter = new TokenTextSplitter({
+ chunkSize: 10000,
+ chunkOverlap: 250,
+ });
+ const docsSummary = await splitter.splitDocuments([video]);
+ const summary = await videoSummarizeChain.run(docsSummary);
+
+ log.debug(`Summarized ${video.metadata.link}:\n ${summary}`, {
+ summary,
+ location: `${prefix}.summarize.docs`,
+ });
+ await summaryCache.set(video.metadata.id, summary);
+
+ summarizedDocs.push(
+ new Document({
+ metadata: video.metadata,
+ pageContent: summary,
+ }),
+ );
+ }
+
+ return summarizedDocs;
+}
+```
+
+Notice the `summaryCache` is used to first ask Redis if the video has already been summarized. If it has, it will return the summary and skip the LLM. This is a great example of how Redis can be used to cache data and avoid unnecessary API calls. Below is an example video summary with questions.
+
+```text title="https://www.youtube.com/watch?v=LaiQFZ5bXaM"
+Summary:
+The video provides a walkthrough of building a real-time stock tracking application
+using Redis Stack, demonstrating its capability to handle multiple data models and
+act as a message broker in a single integrated database. The application maintains
+a watch list of stock symbols, along with real-time trading information and a chart
+updated with live data from the Alpaca API. The presenter uses Redis Stack features
+such as sets, JSON documents, time series, Pub/Sub, and Top-K filter to store and
+manage different types of data. An architecture diagram is provided, explaining the
+interconnection between the front end, API service, and streaming service within
+the application. Code snippets highlight key aspects of the API and streaming
+service written in Python, highlighting the use of Redis Bloom, Redis JSON, Redis
+Time Series, and Redis Search for managing data. The video concludes with a
+demonstration of how data structures are visualized and managed in RedisInsight,
+emphasizing how Redis Stack can simplify the building of a complex real-time
+application by replacing multiple traditional technologies with one solution.
+
+Example Questions and Answers:
+
+Q1: What is Redis Stack and what role does it play in the application?
+Q2: How is the stock watch list stored and managed within the application?
+Q3: What type of data does the application store using time series capabilities of
+Redis Stack?
+Q4: Can you explain the use of the Top-K filter in the application?
+Q5: What methods are used to update the front end with real-time information in
+the application?
+Q6: How does the application sync the watch list with the streaming service?
+Q7: What frontend technologies are mentioned for building the UI of the application?
+Q8: How does Redis Insight help in managing the application data?
+```
+
+The `vector embedding chain` is used to generate vector embeddings for the video summaries. This is done by asking the LLM to generate text embeddings for the summary. The `vector embedding chain` is defined as follows:
+
+```typescript title="services/video-search/src/api/store.ts"
+const vectorStore = new RedisVectorStore(embeddings, {
+ redisClient: client,
+ indexName: `${prefix}-${config.redis.VIDEO_INDEX_NAME}`,
+ keyPrefix: `${prefix}-${config.redis.VIDEO_PREFIX}`,
+ indexOptions: {
+ ALGORITHM: VectorAlgorithms.HNSW,
+ DISTANCE_METRIC: 'IP',
+ },
+});
+```
+
+The vector store uses the `RedisVectorStore` class from LangChain. This class is a wrapper around Redis that allows you to store and search vector embeddings. We are using the `HNSW` algorithm and the `IP` distance metric. For more information on the supported algorithms and distance metrics, see the [Redis vector store documentation](https://redis.io/docs/interact/search-and-query/advanced-concepts/vectors/). We pass the `embeddings` object to the `RedisVectorStore` constructor. This object is defined as follows:
+
+```typescript title="services/video-search/src/api/llms/google.ts"
+new GoogleGenerativeAIEmbeddings({
+ apiKey: config.google.API_KEY,
+ modelName: modelName ?? config.google.EMBEDDING_MODEL,
+ taskType: TaskType.SEMANTIC_SIMILARITY,
+});
+```
+
+Or for OpenAI:
+
+```typescript title="services/video-search/src/api/llms/openai.ts"
+new OpenAIEmbeddings({
+ openAIApiKey: config.openai.API_KEY,
+ modelName: modelName ?? config.openai.EMBEDDING_MODEL,
+ configuration: {
+ organization: config.openai.ORGANIZATION,
+ },
+});
+```
+
+The `embeddings` object is used to generate vector embeddings for the video summaries. These embeddings are then stored in Redis using the `vectorStore`.
+
+```typescript title="services/video-search/src/api/store.ts" {28}
+async function storeVideoVectors(documents: VideoDocument[]) {
+ log.debug('Storing documents...', {
+ location: `${prefix}.store.store`,
+ });
+ const newDocuments: VideoDocument[] = [];
+
+ await Promise.all(
+ documents.map(async (doc) => {
+ const exists = await client.sIsMember(
+ `${prefix}-${config.redis.VECTOR_SET}`,
+ doc.metadata.id,
+ );
+
+ if (!exists) {
+ newDocuments.push(doc);
+ }
+ }),
+ );
+
+ log.debug(`Found ${newDocuments.length} new documents`, {
+ location: `${prefix}.store.store`,
+ });
+
+ if (newDocuments.length === 0) {
+ return;
+ }
+
+ await vectorStore.addDocuments(newDocuments);
+
+ await Promise.all(
+ newDocuments.map(async (doc) => {
+ await client.sAdd(
+ `${prefix}-${config.redis.VECTOR_SET}`,
+ doc.metadata.id,
+ );
+ }),
+ );
+}
+```
+
+Notice that we first check if we have already generated a vector using the Redis Set `VECTOR_SET`. If we have, we skip the LLM and use the existing vector. This avoids unnecessary API calls and can speed things up.
+
+### Redis vector search functionality and AI integration for video Q&A
+
+One of the key features of our application is the ability to search through video content using AI-generated queries. This section will cover how the backend handles search requests and interacts with the AI models.
+
+#### Converting questions into vectors
+
+When a user submits a question through the frontend, the backend performs the following steps to obtain the answer to the question as well as supporting videos:
+
+1. We generate a semantically similar question to the one being asked. This helps to find the most relevant videos.
+1. We then use the `vectorStore` to search for the most relevant videos based on the semantic question.
+1. If we don't find any relevant videos, we search with the original question.
+1. Once we find videos, we call the LLM to answer the question.
+1. Finally, we return the answer and supporting videos to the user.
+
+To answer a question, we first generate a semantically similar question to the one being asked. This is done using the `QUESTION_PROMPT` defined below:
+
+```typescript title="services/video-search/src/api/templates/questions.ts"
+import { PromptTemplate } from 'langchain/prompts';
+
+const questionTemplate = `
+You are an expert in summarizing questions.
+Your goal is to reduce a question down to its simplest form while still retaining the semantic meaning.
+Below you find the question:
+--------
+{question}
+--------
+
+Total output will be a semantically similar question that will be used to search an existing dataset.
+
+SEMANTIC QUESTION:
+`;
+
+export const QUESTION_PROMPT = PromptTemplate.fromTemplate(questionTemplate);
+```
+
+Using this prompt, we generate the `semantic question` and use it to search for videos. We may also need to search using the original `question` if we don't find any videos with the `semantic question`. This is done using the `ORIGINAL_QUESTION_PROMPT` defined below:
+
+```typescript title="services/video-search/src/api/search.ts" {12-14,22,27,37,44,46-52}
+async function getVideos(question: string) {
+ log.debug(
+ `Performing similarity search for videos that answer: ${question}`,
+ {
+ question,
+ location: `${prefix}.search.search`,
+ },
+ );
+
+ const KNN = config.searches.KNN;
+ /* Simple standalone search in the vector DB */
+ return await (vectorStore.similaritySearch(question, KNN) as Promise<
+ VideoDocument[]
+ >);
+}
+
+async function searchVideos(question: string) {
+ log.debug(`Original question: ${question}`, {
+ location: `${prefix}.search.search`,
+ });
+
+ const semanticQuestion = await prompt.getSemanticQuestion(question);
+
+ log.debug(`Semantic question: ${semanticQuestion}`, {
+ location: `${prefix}.search.search`,
+ });
+ let videos = await getVideos(semanticQuestion);
+
+ if (videos.length === 0) {
+ log.debug(
+ 'No videos found for semantic question, trying with original question',
+ {
+ location: `${prefix}.search.search`,
+ },
+ );
+
+ videos = await getVideos(question);
+ }
+
+ log.debug(`Found ${videos.length} videos`, {
+ location: `${prefix}.search.search`,
+ });
+
+ const answerDocument = await prompt.answerQuestion(question, videos);
+
+ return [
+ {
+ ...answerDocument.metadata,
+ question: answerDocument.pageContent,
+ isOriginal: true,
+ },
+ ];
+}
+```
+
+The code above shows the whole process for getting answers from the LLM and returning them to the user. Once relevant videos are identified, the backend uses either Google Gemini or OpenAI's ChatGPT to generate answers. These answers are formulated based on the video transcripts stored in Redis, ensuring they are contextually relevant to the user's query. The `ANSWER_PROMPT` used to ask the LLM for answers is as follows:
+
+```typescript title="services/video-search/src/api/templates/answers.ts"
+import { PromptTemplate } from 'langchain/prompts';
+
+const answerTemplate = `
+You are an expert in answering questions about Redis and Redis Stack.
+Your goal is to take a question and some relevant information extracted from videos and return the answer to the question.
+
+- Try to mostly use the provided video info, but if you can't find the answer there you can use other resources.
+- Make sure your answer is related to Redis. All questions are about Redis. For example, if a question is asking about strings, it is asking about Redis strings.
+- The answer should be formatted as a reference document using markdown. Make all headings and links bold, and add new paragraphs around any code blocks.
+- Your answer should include as much detail as possible and be no shorter than 500 words.
+
+Here is some extracted video information relevant to the question: {data}
+
+Below you find the question:
+--------
+{question}
+--------
+
+Total output will be the answer to the question.
+
+ANSWER:
+`;
+
+export const ANSWER_PROMPT = PromptTemplate.fromTemplate(answerTemplate);
+```
+
+That's it! The backend will now return the answer and supporting videos to the user.
+
+## Going further with semantic answer caching
+
+The application we've built in this tutorial is a great starting point for exploring the possibilities of AI-powered video Q&A. However, there are many ways to improve the application and make it more efficient. One such improvement is to use Redis as a semantic vector cache.
+
+Note in the previous section, we discussed making a call to the LLM to answer every question. There is a performance bottleneck during this step, because LLM response times vary, but can take several seconds. What if there was a way we could prevent unnecessary calls to the LLM? This is where `semantic vector caching` comes in.
+
+### What is semantic vector caching?
+
+Semantic vector caching happens when you take the results of a call to an LLM and cache them alongside the vector embedding for the prompt. In the case of our application, we could generate vector embeddings for the questions and store them in Redis with the answer from the LLM. This would allow us to avoid calling the LLM for similar questions that have already been answered.
+
+You might ask why store the question as a vector? Why not just store the question as a string? The answer is that storing the question as a vector allows us to perform semantic vector similarity searches. So rather than relying on someone asking the exact same question, we can determine an acceptable similarity score and return answers for similar questions.
+
+### How to implement semantic vector caching in Redis
+
+If you're already familiar with storing vectors in Redis, which we have covered in this tutorial, semantic vector caching is an extension of that and operates in essentially the same way. The only difference is that we are storing the question as a vector, rather than the video summary. We are also using the [cache aside](https://www.youtube.com/watch?v=AJhTduDOVCs) pattern. The process is as follows:
+
+1. When a user asks a question, we perform a vector similarity search for existing answers to the question.
+1. If we find an answer, we return it to the user. Thus, avoiding a call to the LLM.
+1. If we don't find an answer, we call the LLM to generate an answer.
+1. We then store the question as a vector in Redis, along with the answer from the LLM.
+
+In order to store the question vectors we need to create a new vector store. This will create an index specifically for the question and answer vector. The code looks like this:
+
+```typescript title="services/video-search/src/api/store.ts" {6-7}
+const answerVectorStore = new RedisVectorStore(embeddings, {
+ redisClient: client,
+ indexName: `${prefix}-${config.redis.ANSWER_INDEX_NAME}`,
+ keyPrefix: `${prefix}-${config.redis.ANSWER_PREFIX}`,
+ indexOptions: {
+ ALGORITHM: VectorAlgorithms.FLAT,
+ DISTANCE_METRIC: 'L2',
+ },
+});
+```
+
+The `answerVectorStore` looks nearly identical to the `vectorStore` we defined earlier, but it uses a different [algorithm and distance metric](https://redis.io/docs/interact/search-and-query/advanced-concepts/vectors/). This algorithm is better suited for similarity searches for our questions.
+
+The following code demonstrates how to use the `answerVectorStore` to check if a similar question has already been answered.
+
+```typescript title="services/video-search/src/api/search.ts" {16-19}
+async function checkAnswerCache(question: string) {
+ const haveAnswers = await answerVectorStore.checkIndexExists();
+
+ if (!(haveAnswers && config.searches.answerCache)) {
+ return;
+ }
+
+ log.debug(`Searching for closest answer to question: ${question}`, {
+ location: `${prefix}.search.getAnswer`,
+ question,
+ });
+
+ /**
+ * Scores will be between 0 and 1, where 0 is most accurate and 1 is least accurate
+ */
+ let results = (await answerVectorStore.similaritySearchWithScore(
+ question,
+ config.searches.KNN,
+ )) as Array<[AnswerDocument, number]>;
+
+ if (Array.isArray(results) && results.length > 0) {
+ // Filter out results with too high similarity score
+ results = results.filter(
+ (result) => result[1] <= config.searches.maxSimilarityScore,
+ );
+
+ const inaccurateResults = results.filter(
+ (result) => result[1] > config.searches.maxSimilarityScore,
+ );
+
+ if (Array.isArray(inaccurateResults) && inaccurateResults.length > 0) {
+ log.debug(
+ `Rejected ${inaccurateResults.length} similar answers that have a score > ${config.searches.maxSimilarityScore}`,
+ {
+ location: `${prefix}.search.getAnswer`,
+ scores: inaccurateResults.map((result) => result[1]),
+ },
+ );
+ }
+ }
+
+ if (Array.isArray(results) && results.length > 0) {
+ log.debug(
+ `Accepted ${results.length} similar answers that have a score <= ${config.searches.maxSimilarityScore}`,
+ {
+ location: `${prefix}.search.getAnswer`,
+ scores: results.map((result) => result[1]),
+ },
+ );
+
+ return results.map((result) => {
+ return {
+ ...result[0].metadata,
+ question: result[0].pageContent,
+ isOriginal: false,
+ };
+ });
+ }
+}
+```
+
+The `similaritySearchWithScore` will find similar questions to the one being asked. It ranks them from `0` to `1`, where `0` is most similar or "closest". We then filter out any results that are too similar, as defined by the `maxSimilarityScore` environment variable. If we find any results, we return them to the user. Using a max score is crucial here, because we don't want to return inaccurate results.
+
+To complete this process, we need to apply the `cache aside` pattern and store the question as a vector in Redis. This is done as follows:
+
+```typescript title="services/video-search/src/api/search.ts" {3,9-15,23-29,50-52}
+async function searchVideos(
+ question: string,
+ { useCache = config.searches.answerCache }: VideoSearchOptions = {},
+) {
+ log.debug(`Original question: ${question}`, {
+ location: `${prefix}.search.search`,
+ });
+
+ if (useCache) {
+ const existingAnswer = await checkAnswerCache(question);
+
+ if (typeof existingAnswer !== 'undefined') {
+ return existingAnswer;
+ }
+ }
+
+ const semanticQuestion = await prompt.getSemanticQuestion(question);
+
+ log.debug(`Semantic question: ${semanticQuestion}`, {
+ location: `${prefix}.search.search`,
+ });
+
+ if (useCache) {
+ const existingAnswer = await checkAnswerCache(semanticQuestion);
+
+ if (typeof existingAnswer !== 'undefined') {
+ return existingAnswer;
+ }
+ }
+
+ let videos = await getVideos(semanticQuestion);
+
+ if (videos.length === 0) {
+ log.debug(
+ 'No videos found for semantic question, trying with original question',
+ {
+ location: `${prefix}.search.search`,
+ },
+ );
+
+ videos = await getVideos(question);
+ }
+
+ log.debug(`Found ${videos.length} videos`, {
+ location: `${prefix}.search.search`,
+ });
+
+ const answerDocument = await prompt.answerQuestion(question, videos);
+
+ if (config.searches.answerCache) {
+ await answerVectorStore.addDocuments([answerDocument]);
+ }
+
+ return [
+ {
+ ...answerDocument.metadata,
+ question: answerDocument.pageContent,
+ isOriginal: true,
+ },
+ ];
+}
+```
+
+When a question is asked, we first check the answer cache. We check both the question and the generated semantic question. If we find an answer, we return it to the user. If we don't find an answer, we call the LLM to generate an answer. We then store the question as a vector in Redis, along with the answer from the LLM. It may look like we're doing more work here than we were without the cache, but keep in mind the LLM is the bottleneck. By doing this, we are avoiding unnecessary calls to the LLM.
+
+Below are a couple screenshots from the application to see what it looks like when you find an existing answer to a question:
+
+
+
+
+
+## Conclusion
+
+In this tutorial, we've explored how to build an AI-powered video Q&A application using Redis, LangChain, and various other technologies. We've covered setting up the environment, processing video uploads, and implementing search functionality. You also saw how to use Redis as a `vector store` and `semantic vector cache`.
+
+> NOTE: Not included in this tutorial is an overview of the frontend `Next.js` app. However, you can find the code in the [GitHub repository](https://github.com/redis-developer/video-qa-semantic-vector-caching) in the `app` directory.
+
+### Key takeaways
+
+- Generative AI can be leveraged to create powerful applications without writing a ton of code.
+- Redis is highly versatile and efficient in handling AI-generated data and vectors.
+- LangChain makes it easy to integrate AI models with vector stores.
+
+Remember, Redis offers an easy start with cloud-hosted instances, which you can sign up for at [redis.com/try-free](https://redis.com/try-free). This makes experimenting with AI and Redis more accessible than ever.
+
+We hope this tutorial inspires you to explore the exciting possibilities of combining AI with powerful databases like Redis to create innovative applications.
+
+## Further reading
+
+- [Perform vector similarity search using Redis](/howtos/solutions/vector/getting-started-vector)
+- [Building a generative AI chatbot using Redis](/howtos/solutions/vector/gen-ai-chatbot)
+- [LangChain JS](https://js.langchain.com/docs/get_started/quickstart)
+ - [Learn LangChain](https://scrimba.com/learn/langchain)
+- [LangChain Redis integration](https://js.langchain.com/docs/integrations/vectorstores/redis)
diff --git a/docs/modules/redisai/index-redisai.mdx b/docs/modules/redisai/index-redisai.mdx
deleted file mode 100644
index f44b89a19bf..00000000000
--- a/docs/modules/redisai/index-redisai.mdx
+++ /dev/null
@@ -1,6 +0,0 @@
----
-id: index-redisai
-title: Redisai
-sidebar_label: RedisAI
-slug: /modules/redisai
----
diff --git a/docs/modules/redisbloom/index-redisbloom.mdx b/docs/modules/redisbloom/index-redisbloom.mdx
index 81708007323..5e25e4515b0 100644
--- a/docs/modules/redisbloom/index-redisbloom.mdx
+++ b/docs/modules/redisbloom/index-redisbloom.mdx
@@ -1,38 +1,38 @@
---
id: index-redisbloom
-title: RedisBloom
-sidebar_label: RedisBloom
+title: Probabilistic Data Structures
+sidebar_label: Probabilistic Data
slug: /modules/redisbloom
---
-RedisBloom extends Redis core to support additional probabilistic data structures. It allows for solving computer science problems in a constant memory space with extremely fast processing and a low error rate. It supports scalable Bloom and Cuckoo filters to determine (with a specified degree of certainty) whether an item is present or absent from a collection.
+Redis Stack provides additional probabilistic data structures. It allows for solving computer science problems in a constant memory space with extremely fast processing and a low error rate. It supports scalable Bloom and Cuckoo filters to determine (with a specified degree of certainty) whether an item is present or absent from a collection.
-The RedisBloom module provides four data types:
+The four probabilistic data types:
- Bloom filter: A probabilistic data structure that can test for presence. A Bloom filter is a data structure designed to tell you, rapidly and memory-efficiently, whether an element is present in a set. Bloom filters typically exhibit better performance and scalability when inserting items (so if you're often adding items to your dataset then Bloom may be ideal).
- Cuckoo filter: An alternative to Bloom filters, Cuckoo filters comes with additional support for deletion of elements from a set. These filters are quicker on check operations.
- Count-min sketch: A count-min sketch is generally used to determine the frequency of events in a stream. You can query the count-min sketch to get an estimate of the frequency of any given event.
-- Top-K: The Top-k probabilistic data structure in RedisBloom is a deterministic algorithm that approximates frequencies for the top k items. With Top-K, you’ll be notified in real time whenever elements enter into or are expelled from your Top-K list. If an element add-command enters the list, the dropped element will be returned.
+- Top-K: The Top-k probabilistic data structure is a deterministic algorithm that approximates frequencies for the top k items. With Top-K, you’ll be notified in real time whenever elements enter into or are expelled from your Top-K list. If an element add-command enters the list, the dropped element will be returned.
### Step 1. Register and subscribe
-Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Enterprise Cloud
+Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Cloud
-### Step 2. Create a database with RedisBloom Module
+### Step 2. Create a database with Redis Stack
### Step 3. Connect to a database
-Follow [this](explore/redisinsight) link to know how to connect to a database
+Follow [this](https://redis.io/docs/ui/insight/) link to know how to connect to a database
-### Step 4. Getting Started with RedisBloom
+### Step 4. Getting Started with Probabilistic Data Structures
-In the next steps you will use some basic RedisBloom commands. You can run them from the Redis command-line interface (redis-cli) or use the CLI available in RedisInsight. (See part 2 of this tutorial to learn more about using the RedisInsight CLI.) To interact with RedisBloom, you use the BF.ADD and BF.EXISTS commands.
+In the next steps you will use some basic commands. You can run them from the Redis command-line interface (redis-cli) or use the CLI available in RedisInsight. (See part 2 of this tutorial to learn more about using the RedisInsight CLI.) To interact with Redis, you use the BF.ADD and BF.EXISTS commands.
-Let’s go ahead and test drive some RedisBloom-specific operations. We will create a basic dataset based on unique visitors’ IP addresses, and you will see how to:
+Let’s go ahead and test drive some probabilistic-specific operations. We will create a basic dataset based on unique visitors’ IP addresses, and you will see how to:
- Create a Bloom filter
- Determine whether or not an item exists in the Bloom filter
@@ -102,4 +102,4 @@ In the above example, the first command shows the result as “1” for both the
### Next Steps
-- Learn more about RedisBloom in the [Quick Start](https://oss.redis.com/redisbloom/Quick_Start/) tutorial.
+- Learn more about Probabilistic data in the [Quick Start](/howtos/quick-start) tutorial.
diff --git a/docs/modules/redisearch/index-redisearch.mdx b/docs/modules/redisearch/index-redisearch.mdx
index 992bd92ce65..f665acfe0cd 100644
--- a/docs/modules/redisearch/index-redisearch.mdx
+++ b/docs/modules/redisearch/index-redisearch.mdx
@@ -1,17 +1,17 @@
---
id: index-redisearch
-title: RediSearch
-sidebar_label: RediSearch
+title: Redis Search
+sidebar_label: Redis Search
slug: /modules/redisearch
---
-RediSearch is a powerful text search and secondary indexing engine, built on top of Redis as a Redis module. Written in C, RediSearch is extremely fast compared to other open-source search engines. It implements multiple data types and commands that fundamentally change what you can do with Redis. RediSearch supports capabilities for search and filtering such as geo-spatial queries, retrieving only IDs (instead of whole documents), and custom document scoring. Aggregations can combine map, filter, and reduce/group-by operations in custom pipelines that run across millions of elements in an instant.
+Redis Search is a powerful text search and secondary indexing engine, built on top of Redis as a Redis module. Written in C, Redis Search is extremely fast compared to other open-source search engines. It implements multiple data types and commands that fundamentally change what you can do with Redis. Redis Search supports capabilities for search and filtering such as geo-spatial queries, retrieving only IDs (instead of whole documents), and custom document scoring. Aggregations can combine map, filter, and reduce/group-by operations in custom pipelines that run across millions of elements in an instant.
-RediSearch also supports auto-completion with fuzzy prefix matching, and atomic real-time insertion of new documents to a search index.With the latest RediSearch 2.0 release, it’s now easier than ever to create a secondary index on top of your existing data. You can just add RediSearch to your existing Redis database, create an index, and start querying it, without having to migrate your data or use new commands for adding data to the index. This drastically lowers the learning curve for new RediSearch users and lets you create indexes on your existing Redis databases—without even having to restart them.
+Redis Search also supports auto-completion with fuzzy prefix matching, and atomic real-time insertion of new documents to a search index.With the latest Redis Search 2.0 release, it’s now easier than ever to create a secondary index on top of your existing data. You can just add Redis Search to your existing Redis database, create an index, and start querying it, without having to migrate your data or use new commands for adding data to the index. This drastically lowers the learning curve for new Redis Search users and lets you create indexes on your existing Redis databases—without even having to restart them.
### Step 1. Register and subscribe
-Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Enterprise Cloud
+Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Cloud
@@ -21,7 +21,7 @@ Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis
### Step 3. Connect to a database
-Follow [this](explore/redisinsight) link to know how to connect to a database
+Follow [this](https://redis.io/docs/ui/insight/) link to know how to connect to a database
### Step 4. Getting Started with Redisearch
@@ -33,7 +33,7 @@ To begin, let’s create a basic dataset based on movies information, which we w
-#### Insert data into RediSearch
+#### Insert data into Redis Search
We are now ready to insert some data. This example uses movies data stored as Redis Hashes, so let’s insert a couple of movies:
@@ -47,7 +47,7 @@ HSET movies:11002 title "Star Wars: Episode V - The Empire Strikes Back" plot "L
(integer) 6
```
-Your Redis Enterprise Cloud database now contains two Hashes. It is simple to retrieve information using the HMGET command, if you know the key of the movies (movies:11002):
+Your Redis Cloud database now contains two Hashes. It is simple to retrieve information using the HMGET command, if you know the key of the movies (movies:11002):
```
> HMGET movies:11002 title rating
@@ -56,7 +56,7 @@ Your Redis Enterprise Cloud database now contains two Hashes. It is simple to re
2) "8.7"
```
-#### Create an index in RediSearch
+#### Create an index in Redis Search
To be able to query the hashes on the field for title, say, or genre, you must first create an index. To create an index, you must define a schema to list the fields and their types that are indexed, and that you can use in your queries.
@@ -80,13 +80,13 @@ In the command above, we:
Before running queries on our new index, though, let’s take a closer look at the elements of the FT.CREATE command:
- idx:movies: the name of the index, which you will use when doing queries
-- ON hash: the type of structure to be indexed. (Note that RediSearch 2.0 supports only the Hash structure, but this parameter will allow RediSearch to index other structures in the future.)
+- ON hash: the type of structure to be indexed. (Note that Redis Search 2.0 supports only the Hash structure, but this parameter will allow Redis Search to index other structures in the future.)
- PREFIX 1 “movies:”: the prefix of the keys that should be indexed. This is a list, so since we want to index only movies:\* keys the number is 1. If you want to index movies and TV shows with the same fields, you could use: PREFIX 2 “movies:” “tv_show:”
- SCHEMA …: defines the schema, the fields, and their type to index. As you can see in the command, we are using TEXT, NUMERIC, and TAG, as well as SORTABLE parameters.
-The RediSearch 2.0 engine will scan the database using the PREFIX values, and update the index based on the schema definition. This makes it easy to add an index to an existing application that uses Hashes, there’s no need to change your code.
+The Redis Search 2.0 engine will scan the database using the PREFIX values, and update the index based on the schema definition. This makes it easy to add an index to an existing application that uses Hashes, there’s no need to change your code.
-#### Search the movies in the RediSearch index
+#### Search the movies in the Redis Search index
You can now use the FT.SEARCH to search your database, for example, to search all movies sorted by release year:
@@ -117,9 +117,14 @@ You can also search “action” movies that contain “star” in the index (in
4) "1980"
```
-The FT.SEARCH command is the base command to search your database, it has many options and is associated with a powerful and rich query syntax that you can find in the documentation. (Note: You can also use the index to do data aggregation using the FT.AGGREGATE command.)
+The FT.SEARCH command is the base command to search your database, it has many options and is associated with a powerful and rich query syntax that you can find in the documentation.
+
+:::tip
+
+You can also use the index to do data aggregation using the FT.AGGREGATE command.
+
+:::
### Next Steps
-- Learn more about RediSearch in the [Getting Started with RediSearch 2.0](https://github.com/RediSearch/redisearch-getting-started/) tutorial on GitHub.
-- [How to list and search Movie database using Redisearch](/howtos/moviesdatabase/getting-started)
+- Learn more about Redis Search in the [Getting Started with Redis Search 2.0](https://github.com/RediSearch/redisearch-getting-started/) tutorial on GitHub.
diff --git a/docs/modules/redisgears/index-redisgears.mdx b/docs/modules/redisgears/index-redisgears.mdx
index e19b9847927..36836d82fd0 100644
--- a/docs/modules/redisgears/index-redisgears.mdx
+++ b/docs/modules/redisgears/index-redisgears.mdx
@@ -1,6 +1,6 @@
---
id: index-redisgears
-title: RedisGears
-sidebar_label: RedisGears
+title: Triggers and Functions
+sidebar_label: Triggers and Functions
slug: /modules/redisgears
---
diff --git a/docs/modules/redisgraph/index-redisgraph.mdx b/docs/modules/redisgraph/index-redisgraph.mdx
index 2c19a4733d6..25f80d3e408 100644
--- a/docs/modules/redisgraph/index-redisgraph.mdx
+++ b/docs/modules/redisgraph/index-redisgraph.mdx
@@ -4,12 +4,14 @@ title: RedisGraph
sidebar_label: RedisGraph
slug: /modules/redisgraph
---
+import GraphEol from '@site/docs/common/_graph-eol.mdx';
+
RedisGraph is a Redis module that enables enterprises to process any kind of connected data much faster than with traditional relational or existing graph databases. RedisGraph implements a unique data storage and processing solution (with sparse-adjacency matrices and GraphBLAS) to deliver the fastest and most efficient way to store, manage, and process connected data in graphs. With RedisGraph, you can process complex transactions 10 - 600 times faster than with traditional graph solutions while using 50 - 60% less memory resources than other graph databases!
### Step 1. Register and subscribe
-Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Enterprise Cloud
+Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Cloud
@@ -19,7 +21,7 @@ Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis
### Step 3. Connect to a database
-Follow [this](explore/redisinsight) link to know how to connect to a database
+Follow [this](https://redis.io/docs/ui/insight/) link to know how to connect to a database
### Step 4. Getting Started with RedisGraph
diff --git a/docs/modules/redisjson/index-redisjson.mdx b/docs/modules/redisjson/index-redisjson.mdx
index c72cd6b7bce..045d8245748 100644
--- a/docs/modules/redisjson/index-redisjson.mdx
+++ b/docs/modules/redisjson/index-redisjson.mdx
@@ -1,31 +1,31 @@
---
id: index-redisjson
-title: RedisJSON
-sidebar_label: RedisJSON
+title: Redis JSON
+sidebar_label: Redis JSON
slug: /modules/redisjson
---
-The RedisJSON module provides in-memory manipulation of JSON documents at high velocity and volume. With RedisJSON, you can natively store document data in a hierarchical, tree-like format to scale and query documents efficiently, significantly improving performance over storing and manipulating JSON with Lua scripts and core Redis data structures.
+Redis Stack provides in-memory manipulation of JSON documents at high velocity and volume. With Redis Stack, you can natively store document data in a hierarchical, tree-like format to scale and query documents efficiently, significantly improving performance over storing and manipulating JSON with Lua scripts and core Redis data structures.
### Step 1. Register and subscribe
-Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Enterprise Cloud
+Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Cloud
-
+
-### Step 2. Create a database with RedisJSON Module
+### Step 2. Create a database with Redis JSON Module
-
+
### Step 3. Connect to a database
-Follow [this](explore/redisinsight) link to know how to connect to a database
+Follow [this](https://redis.io/docs/ui/insight/) link to know how to connect to a database
-### Step 4. Getting Started with RedisJSON
+### Step 4. Getting Started with Redis JSON
-The following steps use some basic RedisJSON commands. You can run them from the Redis command-line interface (redis-cli) or use the CLI available in RedisInsight.
+The following steps use some basic Redis JSON commands. You can run them from the Redis command-line interface (redis-cli) or use the CLI available in RedisInsight.
-To interact with RedisJSON, you will most often use the JSON.SET and JSON.GET commands. Before using RedisJSON, you should familiarize yourself with its commands and syntax as detailed in the documentation: RedisJSON Commands.
+To interact with Redis JSON, you will most often use the JSON.SET and JSON.GET commands. Before using Redis JSON, you should familiarize yourself with its commands and syntax as detailed in the documentation: Redis JSON Commands.
Let’s go ahead and test drive some JSON-specific operations for setting and retrieving a Redis key with a JSON value:
@@ -36,7 +36,7 @@ Let’s go ahead and test drive some JSON-specific operations for setting and re
#### Scalar
-Under RedisJSON, a key can contain any valid JSON value. It can be scalar, objects or arrays. JSON scalar is basically a string. You will have to use the JSON.SET command to set the JSON value. For new Redis keys the path must be the root, so you will use “.” path in the example below. For existing keys, when the entire path exists, the value that it contains is replaced with the JSON value. Here you will use JSON.SET to set the JSON scalar value to “Hello JSON!” Scalar will contain a string that holds “Hello JSON!”
+Under Redis JSON, a key can contain any valid JSON value. It can be scalar, objects or arrays. JSON scalar is basically a string. You will have to use the JSON.SET command to set the JSON value. For new Redis keys the path must be the root, so you will use “.” path in the example below. For existing keys, when the entire path exists, the value that it contains is replaced with the JSON value. Here you will use JSON.SET to set the JSON scalar value to “Hello JSON!” Scalar will contain a string that holds “Hello JSON!”
```
>> JSON.SET scalar . ' "Hello JSON!" '
@@ -144,5 +144,5 @@ A JSON object can also have another object. Here is a simple example of a JSON o
### Next Steps
-- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- Learn more about [Redis JSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
+- [How to build shopping cart app using NodeJS and Redis JSON](/howtos/shoppingcart)
diff --git a/docs/modules/redistimeseries/index-redistimeseries.mdx b/docs/modules/redistimeseries/index-redistimeseries.mdx
index 16f3cb241ba..bde683ffa9b 100644
--- a/docs/modules/redistimeseries/index-redistimeseries.mdx
+++ b/docs/modules/redistimeseries/index-redistimeseries.mdx
@@ -1,27 +1,27 @@
---
id: index-redistimeseries
-title: RedisTimeSeries
-sidebar_label: RedisTimeSeries
+title: Redis Time Series
+sidebar_label: Redis Time Series
slug: /modules/redistimeseries
---
-RedisTimeseries is a Redis module that enhances your experience managing time-series data with Redis. It simplifies the use of Redis for time-series use cases such as internet of things (IoT) data, stock prices, and telemetry. With RedisTimeSeries, you can ingest and query millions of samples and events at the speed of Redis. Advanced tooling such as downsampling and aggregation ensure a small memory footprint without impacting performance. Use a variety of queries for visualization and monitoring with built-in connectors to popular monitoring tools like Grafana, Prometheus, and Telegraf.
+RedisTimeseries is a Redis module that enhances your experience managing time-series data with Redis. It simplifies the use of Redis for time-series use cases such as internet of things (IoT) data, stock prices, and telemetry. With Redis Time Series, you can ingest and query millions of samples and events at the speed of Redis. Advanced tooling such as downsampling and aggregation ensure a small memory footprint without impacting performance. Use a variety of queries for visualization and monitoring with built-in connectors to popular monitoring tools like Grafana, Prometheus, and Telegraf.
### Step 1. Register and subscribe
-Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Enterprise Cloud
+Follow [this link to register](/create/cloud/rediscloud) and subscribe to Redis Cloud
-### Step 2. Create a database with RedisTimeSeries Module
+### Step 2. Create a database with Redis Time Series Module
### Step 3. Connect to a database
-Follow [this](explore/redisinsight) link to know how to connect to a database
+Follow [this](https://redis.io/docs/ui/insight/) link to know how to connect to a database
-### Step 4. Getting Started with RedisTimeSeries
+### Step 4. Getting Started with Redis Time Series
This section will walk you through using some basic RedisTimeseries commands. You can run them from the Redis command-line interface (redis-cli) or use the CLI available in RedisInsight. (See part 2 of this tutorial to learn more about using the RedisInsight CLI.)
Using a basic air-quality dataset, we will show you how to:
@@ -30,11 +30,11 @@ Using a basic air-quality dataset, we will show you how to:
- Add a new sample to the list of series
- Query a range across one or multiple time series
-
+
#### Create a new time series
-Let’s create a time series representing air quality dataset measurements. To interact with RedisTimeSeries you will most often use the TS.RANGE command, but here you will create a time series per measurement using the TS.CREATE command. Once created, all the measurements will be sent using TS.ADD.
+Let’s create a time series representing air quality dataset measurements. To interact with Redis Time Series you will most often use the TS.RANGE command, but here you will create a time series per measurement using the TS.CREATE command. Once created, all the measurements will be sent using TS.ADD.
The sample command below creates a time series and populates it with three entries:
@@ -141,4 +141,4 @@ You can use various aggregation types such as avg, sum, min, max, range, count,
### Next Steps
-- Learn more about RedisTimeSeries in the [Quickstart](https://oss.redis.com/redistimeseries/) tutorial.
+- Learn more about Redis Time Series in the [Quickstart](https://oss.redis.com/redistimeseries/) tutorial.
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview.jpg b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview.jpg
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview.jpg
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview.jpg
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview1.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview1.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argo_preview1.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argo_preview1.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_1.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_1.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_1.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_1.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_10.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_10.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_10.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_10.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_11.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_11.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_11.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_11.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_12.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_12.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_12.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_12.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_13.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_13.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_13.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_13.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_14.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_14.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_14.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_14.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_15.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_15.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_15.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_15.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_16.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_16.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_16.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_16.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_17.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_17.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_17.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_17.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_18.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_18.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_18.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_18.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_2.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_2.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_2.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_2.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_21.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_21.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_21.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_21.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_3.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_3.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_3.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_3.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_4.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_4.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_4.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_4.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_5.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_5.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_5.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_5.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_6.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_6.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_6.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_6.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_7.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_7.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_7.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_7.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_8.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_8.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_8.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_8.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_9.png b/docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_9.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/images/argocd_9.png
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/images/argocd_9.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/argocd/index-argocd.mdx b/docs/operate/_continuous-integration-continuous-deployment/argocd/index-argocd.mdx
similarity index 97%
rename from docs/operate/continuous-integration-continuous-deployment/argocd/index-argocd.mdx
rename to docs/operate/_continuous-integration-continuous-deployment/argocd/index-argocd.mdx
index 2b43733d025..7853b343b4b 100644
--- a/docs/operate/continuous-integration-continuous-deployment/argocd/index-argocd.mdx
+++ b/docs/operate/_continuous-integration-continuous-deployment/argocd/index-argocd.mdx
@@ -6,6 +6,10 @@ slug: /operate/continuous-integration-continuous-deployment/argocd
authors: [ajeet, talon]
---
+import Authors from '@theme/Authors';
+
+
+
## What is an Argo CD?
Argo CD is a combination of the two terms “Argo” and “CD,” [Argo](https://argoproj.github.io/) being an open source container-native workflow engine for Kubernetes. It is a [CNCF-hosted project](https://www.cncf.io/blog/2020/04/07/toc-welcomes-argo-into-the-cncf-incubator/) that provides an easy way to combine all three modes of computing—services, workflows, and event-based—all of which are very useful for creating jobs and applications on Kubernetes. It is an engine that makes it easy to specify, schedule, and coordinate the running of complex workflows and applications on Kubernetes. The CD in the name refers to [continuous delivery](https://en.wikipedia.org/wiki/Continuous_delivery), which is an extension of continuous integration (CI) since it automatically deploys all code changes to a testing and/or production environment after the build stage.
@@ -18,7 +22,11 @@ Argo CD empowers organizations to declaratively build and run cloud native appli
Built specifically to make the continuous deployment process to a Kubernetes cluster simpler and more efficient, Argo CD solves multiple challenges, such as the need to set up and install additional tools outside of Jenkins for a complete CI/CD process to Kubernetes, the need to configure access control to Kubernetes in and out (including cloud platforms), the need to have visibility of deployment status once a new app gets pushed to a Kubernetes cluster, and more.
-Please note that Argo CD isn’t just deployed inside of Kubernetes but should be looked at as an extension of Kubernetes as it uses existing Kubernetes resources and functionalities like etcd and controllers to store data and monitor real-time updates of application state.
+:::note
+
+Argo CD isn’t just deployed inside of Kubernetes but should be looked at as an extension of Kubernetes as it uses existing Kubernetes resources and functionalities like etcd and controllers to store data and monitor real-time updates of application state.
+
+:::
## How does Argo CD work?
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-auth.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-auth.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-auth.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-auth.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-config.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-config.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-config.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-config.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-config2.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-config2.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-config2.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-config2.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-demoapp.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-demoapp.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-demoapp.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-demoapp.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-login.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-login.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-login.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-login.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-merge.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-merge.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-merge.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-merge.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-proj.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-proj.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-proj.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-proj.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-redis.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-redis.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circleci-redis.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circleci-redis.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/circlecidiagram.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/circlecidiagram.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/circlecidiagram.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/circlecidiagram.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-envir.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-envir.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-envir.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-envir.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-setup.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-setup.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-setup.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-setup.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-trigger.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-trigger.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/heroku-trigger.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/heroku-trigger.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/images/rate-limiting-example.png b/docs/operate/_continuous-integration-continuous-deployment/circleci/images/rate-limiting-example.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/images/rate-limiting-example.png
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/images/rate-limiting-example.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/circleci/index-circleci.mdx b/docs/operate/_continuous-integration-continuous-deployment/circleci/index-circleci.mdx
similarity index 99%
rename from docs/operate/continuous-integration-continuous-deployment/circleci/index-circleci.mdx
rename to docs/operate/_continuous-integration-continuous-deployment/circleci/index-circleci.mdx
index 8450948ce89..6a6157ff692 100644
--- a/docs/operate/continuous-integration-continuous-deployment/circleci/index-circleci.mdx
+++ b/docs/operate/_continuous-integration-continuous-deployment/circleci/index-circleci.mdx
@@ -6,6 +6,10 @@ slug: /operate/continuous-integration-continuous-deployment/circleci
authors: [talon, ajeet]
---
+import Authors from '@theme/Authors';
+
+
+
## **What is CircleCI?**
diff --git a/docs/operate/_continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx b/docs/operate/_continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx
new file mode 100644
index 00000000000..8cca1b9982d
--- /dev/null
+++ b/docs/operate/_continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx
@@ -0,0 +1,10 @@
+---
+id: index-continuous-integration-continuous-deployment
+title: Continuous Integration/Deployment
+sidebar_label: Overview
+slug: /operate/continuous-integration-continuous-deployment
+---
+
+import RedisCard from '@theme/RedisCard';
+
+The following links show you the different ways to embed Redis into your continuous integration and continuous deployment process.
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image1.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image1.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image1.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image1.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image10.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image10.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image10.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image10.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image11.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image11.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image11.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image11.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image12.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image12.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image12.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image12.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image13.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image13.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image13.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image13.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image14.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image14.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image14.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image14.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image15.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image15.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image15.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image15.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image16.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image16.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image16.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image16.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image17.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image17.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image17.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image17.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image18.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image18.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image18.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image18.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image19.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image19.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image19.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image19.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image2.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image2.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image2.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image2.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image20.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image20.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image20.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image20.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image3.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image3.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image3.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image3.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image4.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image4.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image4.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image4.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image5.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image5.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image5.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image5.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image6.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image6.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image6.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image6.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image7.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image7.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image7.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image7.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image8.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image8.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image8.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image8.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/image9.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image9.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/image9.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/image9.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/images/status.png b/docs/operate/_continuous-integration-continuous-deployment/jenkins/images/status.png
similarity index 100%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/images/status.png
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/images/status.png
diff --git a/docs/operate/continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx b/docs/operate/_continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx
similarity index 99%
rename from docs/operate/continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx
rename to docs/operate/_continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx
index e2e85f75e56..5567345ef20 100644
--- a/docs/operate/continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx
+++ b/docs/operate/_continuous-integration-continuous-deployment/jenkins/index-jenkins.mdx
@@ -6,6 +6,10 @@ slug: /operate/continuous-integration-continuous-deployment/jenkins
authors: [ajeet, matthew]
---
+import Authors from '@theme/Authors';
+
+
+
[Jenkins](https://www.jenkins.io/) is currently [the most popular CI tool](https://cd.foundation/announcement/2019/08/14/jenkins-celebrates-15-years/), with ~15M users. It is an open source automation server which enables developers to reliably build, test, and deploy their software. It was forked in 2011 from a project called Hudson after a [dispute with Oracle](https://www.infoq.com/news/2011/01/jenkins/), and is used for [Continuous Integration and Continuous Delivery (CI/CD)](https://stackoverflow.com/questions/28608015/continuous-integration-vs-continuous-delivery-vs-continuous-deployment) and test automation. Jenkins is based on Java and provides over [1700 plugins](https://plugins.jenkins.io/) to automate your developer workflow and save a lot of your time in executing your repetitive tasks.
diff --git a/docs/operate/_index-operate.mdx b/docs/operate/_index-operate.mdx
new file mode 100644
index 00000000000..676998d6b9d
--- /dev/null
+++ b/docs/operate/_index-operate.mdx
@@ -0,0 +1,33 @@
+---
+id: index-operate
+title: Operate Your Redis Database
+sidebar_label: Overview
+slug: /operate
+---
+
+import RedisCard from '@theme/RedisCard';
+
+The following links demonstrate various ways to provision Redis and accelerate app deployment using Devops.
+
+
+ 
+
+
+# Explore by Category
+
+
diff --git a/docs/operate/continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx b/docs/operate/continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx
deleted file mode 100644
index 097a4459f96..00000000000
--- a/docs/operate/continuous-integration-continuous-deployment/index-continuous-integration-continuous-deployment.mdx
+++ /dev/null
@@ -1,36 +0,0 @@
----
-id: index-continuous-integration-continuous-deployment
-title: Continuous Integration/Deployment
-sidebar_label: Overview
-slug: /operate/continuous-integration-continuous-deployment
----
-
-import RedisCard from '@site/src/theme/RedisCard';
-
-The following links show you the different ways to embed Redis into your continuous integration and continuous deployment process.
-
-
-
diff --git a/docs/operate/index-operate.mdx b/docs/operate/index-operate.mdx
deleted file mode 100644
index 689ce421eb8..00000000000
--- a/docs/operate/index-operate.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-id: index-operate
-title: Operate Your Redis Database
-sidebar_label: Overview
-slug: /operate
----
-
-import RedisCard from '@site/src/theme/RedisCard';
-
-The following links demonstrate various ways to provision Redis and accelerate app deployment using Devops.
-
-
-
-
-
-# Explore by Category
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## Top 5 Reasons why DevOps Teams Love Redis Enterprise
-[---> Read the blog](https://redis.com/blog/why-devops-teams-love-redis-enterprise/)
-
-
-
-
-
-
-## DevOps Tools
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-})
- })
- }){kind=logo}
- })
- 
+ 
+ 
+
+Picture 3 depicts the entity relationships between `products`, `product_details`, and `product_images` and represents a normalized data model with a single denormalized field image in the `products` table. The reason for this is to avoid having to use a SQL JOIN when selecting the products for the list view. Using this model, the SQL query used to get the data needed for the list view might resemble **Code Example 1**.
+
+```sql title="Code Example 1"
+SELECT
+ p.id, p.name, p.image, p.price, pi.url
+FROM
+ products p
+```
+
+### 1-to-1 Relationships using Redis
+
+In Redis, similar to a relational database, you can create a collection called `products` and another called `product_details`. But with Redis JSON you can improve this by simply embedding `product_images` and `product_details` directly into the `Products` collection. Then, when you query the `Products` collection, specify which fields you need based on which view you are trying to create.
+
+This will allow you to easily keep all the data in one place. This is called the **Embedded Pattern** and is one of the most common patterns you will see in NoSQL document databases like Redis JSON. **Code Example 2** uses Python and a client library called Redis OM (an ORM for Redis) to model `Products` and `ProductDetails`. Note that `ProductDetails` is embedded into `Products` directly, so all of the data for a product will be stored within the same document.
+
+```python title="Code Example 2"
+class ProductDetail(EmbeddedJsonModel):
+ description: str
+ manufacturer: str
+ dimensions: str
+ weight: str
+ images: List[str]
+
+class Product(JsonModel):
+ name: str = Field(index=True)
+ image: str = Field(index=True)
+ price: int = Field(index=True)
+ details: Optional[ProductDetail]
+```
+
+**Code Example 2** also shows how you can index fields using Redis OM and Redis Search. Doing this turns Redis into not only a document store but also a search engine since Redis Search enables secondary indexing and searching. When you create models using Redis OM, it will automatically manage secondary indexes with Redis Search on your behalf.
+
+Using Redis OM we can write a function to retrieve our `products` list for the list view, as shown in **Code Example 3**.
+
+```python title="Code Example 3"
+async def get_product_list():
+ results = await connections \
+ .get_redis_connection() \
+ .execute_command(
+ f'FT.SEARCH {Product.Meta.index_name} * LIMIT 0 10 RETURN 3 name image price'
+ )
+ return Product.from_redis(results)
+```
+
+Notice that in **Code Example 3** we are using the `FT.SEARCH` command, which specifies the index managed on our behalf by Redis OM and returns three fields: name, image, and price. While the documents all have details and images embedded, we don’t want to display them in the list view so we don’t need to query them. When we want the detailed view, we can query an entire Product document. See **Code Example 4** for how to query an entire document.
+
+```python title="Code Example 4"
+async def get_product_details(product_id: str):
+ return await Product.get(product_id)
+```
+
+When using Redis, you can use RedisInsight as a GUI tool to visualize and interact with the data in your database. **Picture 4** shows you what a `Products` document looks like.
+
+Picture 4
+
+
+## Download the E-book
+
+