diff --git a/content/develop/ai/context-engine/_index.md b/content/develop/ai/context-engine/_index.md
index 9ca075f6c2..0364923a73 100644
--- a/content/develop/ai/context-engine/_index.md
+++ b/content/develop/ai/context-engine/_index.md
@@ -33,8 +33,6 @@ Redis Iris is a production-ready context engine for AI agents that:
- **Keeps data fresh**: Data Integration streams live changes from relational databases into Redis within seconds
- **Deploys your way**: All four services are available fully managed on Redis Cloud or self-managed on your own infrastructure, via REST API
-See [how Redis Iris works](/content/develop/ai/context-engine/concepts/_index.md) for the mental model before you start building.
-
## Why use Redis Iris?
@@ -58,92 +56,6 @@ See [how Redis Iris works](/content/develop/ai/context-engine/concepts/_index.md
-## Quick example
-
-Search LangCache before calling your LLM; return a cached response in milliseconds if a semantically similar prompt has been seen before:
-
-```json
-POST /v1/caches/{cacheId}/entries/search
-{
- "prompt": "What are the features of Product A?"
-}
-```
-
-If the response is empty (cache miss), call your LLM and store the result:
-
-```json
-POST /v1/caches/{cacheId}/entries
-{
- "prompt": "What are the features of Product A?",
- "response": "Product A includes X, Y, and Z features..."
-}
-```
-
-See [LangCache API examples](/content/develop/ai/context-engine/langcache/api-examples.md) and the [Agent Memory REST API quickstart](/content/develop/ai/context-engine/agent-memory/rest-api-quickstart.md) for more.
-
-Redis Iris context engine includes four services:
-
-- **[LangCache](/content/develop/ai/context-engine/langcache/_index.md)**: A semantic caching service that stores and reuses LLM responses for similar queries, reducing API costs and improving response latency.
-- **[Agent Memory](/content/develop/ai/context-engine/agent-memory/_index.md)**: A persistent memory service that maintains short-term session memory and long-term memory across agent interactions.
-- **[Context Retriever](/content/develop/ai/context-engine/context-retriever/_index.md)**: Turns your business data into structured tools that AI agents can safely and reliably use, defined once and reused across all agents.
-- **[Data integration](/content/develop/ai/context-engine/data-integration/_index.md)**: Syncs live data from your existing relational databases into Redis Cloud so agents always have access to fresh, accurate business data.
-
-All four services are available fully managed on [Redis Cloud](/content/operate/iris/_index.md) using the REST API, with no database setup or management required, or self-managed on your own infrastructure.
-
-## LangCache
-
-[LangCache](/content/develop/ai/context-engine/langcache/_index.md) uses semantic similarity to match incoming prompts against previously cached LLM responses. When LangCache finds a semantically similar response in the cache, it returns that response immediately without making an LLM call.
-
-**Key benefits:**
-
-- **Lower LLM costs**: Reduces redundant API calls for semantically equivalent queries.
-- **Faster responses**: Serves cached answers in milliseconds instead of waiting for an LLM.
-- **Managed embeddings**: LangCache handles embedding generation automatically.
-- **Cache control**: Configure similarity thresholds, time-to-live (TTL) settings, and eviction policies.
-
-LangCache works well for AI assistants, chatbots, retrieval-augmented generation (RAG) applications, AI agents, and centralized AI gateway services.
-
-[Get started with LangCache](/content/develop/ai/context-engine/langcache/_index.md)
-
-## Agent Memory
-
-[Agent Memory](/content/develop/ai/context-engine/agent-memory/_index.md) gives AI agents a structured, persistent memory layer using a two-tier model:
-
-- **Session memory** (short-term or working memory): Holds the current conversation state and session metadata, with configurable TTL-based expiration.
-- **Long-term memory**: Stores information extracted from past sessions, including user preferences and learned patterns, as text with vector embeddings for semantic retrieval.
-
-Promotion from session memory to long-term memory is automatic and non-blocking. As a conversation progresses, the service asynchronously extracts and stores important information in the background, keeping agent interactions responsive. You can also create long-term memories directly using the API for bulk imports or external knowledge sources.
-
-Agent Memory is available through Python and TypeScript SDKs and a REST API.
-
-[Get started with Agent Memory](/content/develop/ai/context-engine/agent-memory/_index.md)
-
-## Context Retriever
-
-Agents don't fail because they lack data. They fail because they don't know how to use it. Context Retriever turns your raw business data into structured tools that agents can reliably act on, without requiring each project to rediscover how your data works.
-
-You define your data model once, specifying the entities that matter (such as customers or orders) and the fields agents need. Context Retriever automatically generates the tools agents use to query and work with that data. Agents never access your database directly. They call the generated tools, and the system handles the rest.
-
-**Key benefits:**
-
-- **Define once, reuse everywhere**: Business context is captured once and shared across all agents.
-- **Automatic tool generation**: Tools are generated from your data model, not hand-coded per agent.
-- **Controlled access**: Each agent requires a key, and access tags automatically filter what data each agent can see.
-- **Governed by design**: Agents can only use tools that have been explicitly defined, with no direct database access.
-
-[Get started with Context Retriever](/content/develop/ai/context-engine/context-retriever/_index.md)
-
-## Data integration
-
-AI agents are only as reliable as the data they work with. [Redis Data Integration (RDI)](/content/operate/rc/rdi/_index.md) keeps your Redis Cloud database in sync with your existing relational databases, including Oracle, MySQL, PostgreSQL, and SQL Server, so agents always have access to current, accurate business data without querying slow primary databases directly.
-
-RDI uses a data pipeline that performs an initial sync of your source data into Redis, then captures changes in real time. Updates from your primary database appear in Redis within seconds, eliminating stale data and cache misses. Your agents interact only with Redis, which provides fast and predictable query performance.
-
-**Key benefits:**
-
-- **Always-fresh data**: Changes in your source database propagate to Redis within seconds.
-- **No direct database access**: Agents query Redis, not your production databases.
-- **Minimal setup**: No infrastructure to manage. Redis Cloud handles the pipeline.
-- **Broad source support**: Works with Oracle, MySQL, PostgreSQL, MariaDB, SQL Server, and AWS Aurora.
+## Next steps
-[Get started with Data integration](/content/develop/ai/context-engine/data-integration/_index.md)
+Learn [how Redis Iris works](/content/develop/ai/context-engine/concepts/_index.md), from the agent request to where each kind of context lives.
diff --git a/content/operate/iris/_index.md b/content/operate/iris/_index.md
index f7344fc5a0..d8ee19646c 100644
--- a/content/operate/iris/_index.md
+++ b/content/operate/iris/_index.md
@@ -14,6 +14,9 @@ bannerText: LangCache, Agent Memory, and Context Retriever are currently availab
Redis Iris context engine provides managed and self-managed services for building AI applications with persistent memory, semantic caching, and governed access to business data.
+
+{width="100%" class="border border-redis-pen-300 rounded-lg"}
+
Use this section to deploy, configure, and operate Redis Iris services. Developer guides and API integration documentation remain under [Develop with Redis]({{< relref "/develop/ai/context-engine" >}}).
@@ -30,6 +33,14 @@ Redis Iris services are available as managed services on Redis Cloud. All Redis
Create and manage Redis Iris services through the Redis Cloud console without deploying the supporting infrastructure yourself.
+- [Create a Redis Agent Memory service]({{< relref "/operate/iris/agent-memory/create-service" >}})
+- [Create a Redis Context Retriever service]({{< relref "/operate/iris/context-retriever/create-service" >}})
+- [Create a LangCache service]({{< relref "/operate/iris/langcache/create-service" >}})
+
### Self-managed
Deploy Redis Iris services on Kubernetes when you need to operate them on your own infrastructure.
+
+- [Self-managed Redis Agent Memory]({{< relref "/operate/iris/agent-memory/self-managed" >}})
+- [Self-managed Redis Context Retriever]({{< relref "/operate/iris/context-retriever/self-managed" >}})
+- [Self-managed LangCache]({{< relref "/operate/iris/langcache/self-managed" >}})
diff --git a/content/operate/iris/agent-memory/_index.md b/content/operate/iris/agent-memory/_index.md
index 6ad8e09da7..83cc23a099 100644
--- a/content/operate/iris/agent-memory/_index.md
+++ b/content/operate/iris/agent-memory/_index.md
@@ -9,20 +9,24 @@ categories:
- iris
weight: 10
hideListLinks: true
+bannerText: Redis Agent Memory on Redis Cloud is currently available as a public preview. Features and behavior are subject to change.
---
Redis Agent Memory provides persistent session memory and long-term memory for AI agents and applications.
-## Deployment options
-
-### Self-managed
+
+{width="75%" class="border border-redis-pen-300 rounded-lg"}
-Deploy, configure, secure, and operate Redis Agent Memory on your own Kubernetes infrastructure.
-
-[Open the self-managed Redis Agent Memory documentation]({{< relref "/operate/iris/agent-memory/self-managed" >}})
+## Deployment options
### Redis Cloud
Use Redis Agent Memory as a managed service on Redis Cloud.
[Create a Redis Agent Memory service]({{< relref "/operate/iris/agent-memory/create-service" >}}), [configure its AI models]({{< relref "/operate/iris/agent-memory/model-configuration" >}}), or [view and manage an existing service]({{< relref "/operate/iris/agent-memory/view-service" >}}).
+
+### Self-managed
+
+Deploy, configure, secure, and operate Redis Agent Memory on your own Kubernetes infrastructure.
+
+[Open the self-managed Redis Agent Memory documentation]({{< relref "/operate/iris/agent-memory/self-managed" >}})
diff --git a/content/operate/iris/agent-memory/create-service.md b/content/operate/iris/agent-memory/create-service.md
index aa4214785e..53cea6e0a3 100644
--- a/content/operate/iris/agent-memory/create-service.md
+++ b/content/operate/iris/agent-memory/create-service.md
@@ -21,12 +21,9 @@ Redis Agent Memory provides a persistent, structured memory layer that AI agents
To create a Redis Agent Memory service, you will need a Redis Cloud database. If you don't have one, see [Create a database]({{< relref "/operate/rc/databases/create-database" >}}).
-> [!NOTE]
-> Redis Agent Memory does not support the following databases during public preview:
-> - [Redis Flex]({{< relref "operate/rc/databases/create-database/create-flex-database">}}) databases
-> - Databases using [AWS PrivateLink]({{< relref "operate/rc/security/aws-privatelink">}}) connectivity
-> - [Active-Active]({{< relref "/operate/rc/databases/active-active" >}}) databases
-> - Databases with the [default user]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) turned off
+
+During public preview, Redis Agent Memory doesn't support [Redis Flex]({{< relref "operate/rc/databases/create-database/create-flex-database">}}) databases, databases using [AWS PrivateLink]({{< relref "operate/rc/security/aws-privatelink">}}) connectivity, [Active-Active]({{< relref "/operate/rc/databases/active-active" >}}) databases, or databases with the [default user]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) turned off.
+
## Create an Agent Memory service
diff --git a/content/operate/iris/agent-memory/self-managed/_index.md b/content/operate/iris/agent-memory/self-managed/_index.md
index d770a7744e..1d7539dbab 100644
--- a/content/operate/iris/agent-memory/self-managed/_index.md
+++ b/content/operate/iris/agent-memory/self-managed/_index.md
@@ -9,6 +9,8 @@ description: Deploy, configure, secure, and operate Redis Agent Memory on a self
linkTitle: Self-managed
weight: 40
hideListLinks: true
+bannerText: Redis Agent Memory self-managed is currently in private preview and subject to change. A license key is required to deploy. Contact your Redis representative or [contact sales](https://redis.io/contact/).
+bannerChildren: true
aliases:
- /develop/ai/context-engine/agent-memory/self-managed/
---
@@ -25,11 +27,6 @@ is the shared Data Plane API for Redis Cloud and self-managed deployments. The
[Control Plane API reference]({{< relref "/operate/iris/agent-memory/self-managed/control-plane-api-reference" >}})
documents the self-managed admin endpoints for stores and agent keys.
-> [!NOTE]
-> Self-managed Redis Agent Memory is available as a private preview. You need a
-> license key to deploy it. Contact your Redis representative or
-> [contact sales](https://redis.io/contact/).
-
## What you are deploying
A standard self-managed Redis Agent Memory deployment contains:
diff --git a/content/operate/iris/context-retriever/_index.md b/content/operate/iris/context-retriever/_index.md
index 38c7a16ce4..7e62cc77fb 100644
--- a/content/operate/iris/context-retriever/_index.md
+++ b/content/operate/iris/context-retriever/_index.md
@@ -15,14 +15,19 @@ bannerChildren: true
Redis Context Retriever helps teams expose operational context to AI agents through schema-first retrieval. It models the entities, fields, keys, and relationships that matter to an agent workflow, then presents that context through a governed tool surface the agent can call at runtime. Context Retriever helps an AI agent understand what business objects exist, how they connect, and which paths are safe to use.
+
+{width="75%" class="border border-redis-pen-300 rounded-lg"}
+
When you set up Redis Context Retriever, you model the objects that matter to your agent workflow and connect the relationships between them. You can do this through the UI, the [Context Surfaces Python Client](https://pypi.org/project/redis-context-retriever/), or the `ctxctl` CLI (available when you install the Python client). Context Retriever uses those relationships to automatically create and deploy retrieval tools from your entity model.
When an agent needs context during execution, it calls the MCP tools Context Retriever exposes. Instead of guessing which tool to use or generating SQL, the agent follows the defined entity paths and gets back structured, live, operational context.
For more details, see the [Redis Context Retriever overview]({{< relref "/develop/ai/context-engine/context-retriever" >}}).
-To deploy Context Retriever on your own Kubernetes infrastructure instead of Redis Cloud, see [self-managed Context Retriever]({{< relref "/operate/iris/context-retriever/self-managed" >}}).
-
## Get started with Context Retriever on Redis Cloud
{{< embed-md "rc-context-retriever-get-started.md" >}}
+
+## Get started with self-managed Context Retriever
+
+To deploy Context Retriever on your own Kubernetes infrastructure instead of Redis Cloud, see [self-managed Context Retriever]({{< relref "/operate/iris/context-retriever/self-managed" >}}).
diff --git a/content/operate/iris/context-retriever/create-service.md b/content/operate/iris/context-retriever/create-service.md
index 359519d408..2a681d423c 100644
--- a/content/operate/iris/context-retriever/create-service.md
+++ b/content/operate/iris/context-retriever/create-service.md
@@ -17,7 +17,7 @@ Redis Context Retriever helps teams expose operational context to AI agents thro
## Prerequisites and limitations
-To create a Redis Context Retriever service, you will need a Redis Cloud database that already has relevant data. If you don't have one, see [Create a database]({{< relref "/operate/rc/databases/create-database" >}}). If your source data lives in a relational database, use [Redis Data Integration (RDI)]({{< relref "/operate/rc/rdi" >}}) to ingest it into a Redis Cloud database first.
+To create a Redis Context Retriever service, you will need a Redis Cloud database that already has relevant data. If you don't have one, see [Create a database]({{< relref "/operate/rc/databases/create-database" >}}).
> [!NOTE]
> Redis Context Retriever does not support the following databases during public preview:
diff --git a/content/operate/iris/langcache/_index.md b/content/operate/iris/langcache/_index.md
index 14c56ea073..7b5180a1e4 100644
--- a/content/operate/iris/langcache/_index.md
+++ b/content/operate/iris/langcache/_index.md
@@ -17,14 +17,19 @@ aliases:
LangCache is a semantic caching service available as a REST API that stores LLM responses for fast and cheaper retrieval, built on the Redis vector database. By using semantic caching, you can significantly reduce API costs and lower the average latency of your generative AI applications.
+
+{width="75%" class="border border-redis-pen-300 rounded-lg"}
+
For more information about how LangCache works, see the [LangCache overview]({{< relref "/develop/ai/context-engine/langcache" >}}).
+## Get started with LangCache on Redis Cloud
+
+{{< embed-md "rc-langcache-get-started.md" >}}
+
+## Get started with self-managed LangCache
+
To deploy LangCache on your own Kubernetes infrastructure instead of Redis Cloud, see [self-managed LangCache]({{< relref "/operate/iris/langcache/self-managed" >}}).
## LLM cost reduction with LangCache
{{< embed-md "langcache-cost-reduction.md" >}}
-
-## Get started with LangCache on Redis Cloud
-
-{{< embed-md "rc-langcache-get-started.md" >}}
diff --git a/content/operate/radar/_index.md b/content/operate/radar/_index.md
index d637efbe0a..98e8df678a 100644
--- a/content/operate/radar/_index.md
+++ b/content/operate/radar/_index.md
@@ -13,6 +13,9 @@ weight: 47
Redis Radar give you one place to view the status of every Redis cluster in your fleet. Instead of checking the status of your clusters individually, get a complete view of them all with Redis Radar.
+
+{width="100%" class="border border-redis-pen-300 rounded-lg"}
+
Radar connects to each cluster, collects its state, and presents one fleet-wide view across Redis Software, Redis Cloud, Redis Open Source, Amazon ElastiCache, and Google Memorystore. Radar is primarily a visibility tool. Connecting a cluster to Radar does not change how that cluster runs on its own.
## How you run Radar
diff --git a/content/operate/rc/rdi/_index.md b/content/operate/rc/rdi/_index.md
index b19f098d98..98cf2b3ac3 100644
--- a/content/operate/rc/rdi/_index.md
+++ b/content/operate/rc/rdi/_index.md
@@ -16,6 +16,9 @@ tocEmbedHeaders: true
Redis Cloud now supports [Redis Data Integration (RDI)](/content/integrate/redis-data-integration/_index.md), a fast and simple way to bring your data into Redis from other types of primary databases.
+
+{width="75%" class="border border-redis-pen-300 rounded-lg"}
+
A relational database usually handles queries much more slowly than a Redis database. If your application uses a relational database and makes many more reads than writes (which is the typical case) then you can improve performance by using Redis as a cache to handle the read queries quickly. Redis Cloud uses [ingest](/content/integrate/redis-data-integration/_index.md) to help you offload all read queries from the application database to Redis automatically.
Using a data pipeline lets you have a cache that is always ready for queries. RDI Data pipelines ensure that any changes made to your primary database are captured in your Redis cache within a few seconds, preventing cache misses and stale data within the cache.
diff --git a/content/operate/rdi.md b/content/operate/rdi.md
index 03fdc452c9..42ee24b3ea 100644
--- a/content/operate/rdi.md
+++ b/content/operate/rdi.md
@@ -12,6 +12,9 @@ weight: 60
Redis Data Integration (RDI) is a [change data capture](https://en.wikipedia.org/wiki/Change_data_capture) (CDC) system that tracks changes to the data in a non-Redis source database and makes corresponding changes to a Redis target database. You can use the target as a cache to improve performance because it will typically handle read queries much faster than the source.
+
+{width="75%" class="border border-redis-pen-300 rounded-lg"}
+
See the main [RDI docs section]({{< relref "/integrate/redis-data-integration" >}})
under [Libraries and tools]({{< relref "/integrate" >}}) to learn how to install and use RDI on your own servers. See the
[Redis Cloud RDI guide]({{< relref "/operate/rc/rdi" >}}) to learn how to set up RDI for a cloud database.
diff --git a/static/images/radar/radar-overview.png b/static/images/radar/radar-overview.png
new file mode 100644
index 0000000000..fd65e5f8e1
Binary files /dev/null and b/static/images/radar/radar-overview.png differ
diff --git a/static/images/rc/agent-memory-get-started.png b/static/images/rc/agent-memory-get-started.png
new file mode 100644
index 0000000000..b88727b6da
Binary files /dev/null and b/static/images/rc/agent-memory-get-started.png differ
diff --git a/static/images/rc/context-retriever-get-started.png b/static/images/rc/context-retriever-get-started.png
new file mode 100644
index 0000000000..1361a7d20d
Binary files /dev/null and b/static/images/rc/context-retriever-get-started.png differ
diff --git a/static/images/rc/iris-overview.png b/static/images/rc/iris-overview.png
new file mode 100644
index 0000000000..5e51410776
Binary files /dev/null and b/static/images/rc/iris-overview.png differ
diff --git a/static/images/rc/langcache-get-started.png b/static/images/rc/langcache-get-started.png
new file mode 100644
index 0000000000..bf9860b211
Binary files /dev/null and b/static/images/rc/langcache-get-started.png differ
diff --git a/static/images/rc/rdi-get-started.png b/static/images/rc/rdi-get-started.png
new file mode 100644
index 0000000000..7244d4638e
Binary files /dev/null and b/static/images/rc/rdi-get-started.png differ