- {{< image-card image="images/ai-brain.svg" alt="Agent Memory icon" title="Agent Memory" url="/develop/ai/context-engine/agent-memory" description="Self-hostable. Store session memory and long-term memory for your agents using Redis." >}}
- {{< image-card image="images/ai-cube.svg" alt="Context Retriever icon" title="Context Retriever" url="/develop/ai/context-engine/context-retriever" description="Self-hostable. Define your data model once and generate the tools agents call at runtime." >}}
+
+ {{< image-card image="images/ai-brain.svg" alt="Redis Agent Memory icon" title="Redis Agent Memory" url="/operate/iris/agent-memory" description="Create and manage a service on Redis Cloud or deploy it on your own infrastructure." >}}
+ {{< image-card image="images/ai-cube.svg" alt="Redis Context Retriever icon" title="Redis Context Retriever" url="/operate/iris/context-retriever" description="Create and manage governed retrieval tools for AI agents." >}}
+ {{< image-card image="images/ai-LLM-memory.svg" alt="LangCache icon" title="LangCache" url="/operate/iris/langcache" description="Create, configure, and monitor semantic caches for AI applications." >}}
-## Self-hosted Redis Iris services
+## Deployment options
-### Agent Memory
+Redis Iris services are available as managed services on Redis Cloud. Redis Agent Memory and Redis Context Retriever are also available for self-managed deployment.
-[Redis Agent Memory]({{< relref "/develop/ai/context-engine/agent-memory" >}}) gives AI agents a persistent, structured memory layer using a two-tier model:
+### Redis Cloud
-- **Session memory**: Holds the current conversation state with configurable TTL-based expiration.
-- **Long-term memory**: Stores information extracted from past sessions as text with vector embeddings for semantic retrieval.
+Create and manage Redis Iris services through the Redis Cloud console without deploying the supporting infrastructure yourself.
-Agent Memory is available as a REST API and Python SDK. You can self-host it on your own infrastructure or use it as a fully managed service on Redis Cloud.
+### Self-managed
-[Install Agent Memory]({{< relref "/develop/ai/context-engine/agent-memory/self-managed" >}})
-
-### Context Retriever
-
-[Context Retriever]({{< relref "/develop/ai/context-engine/context-retriever" >}}) turns your business data into structured tools that AI agents can reliably call at runtime. You define your data model once by specifying the entities and fields your agents need, and Context Retriever automatically generates the retrieval tools. Agents never access your database directly.
-
-**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 filter what data each agent can see.
-
-Context Retriever is self-hostable or available as a fully managed service on Redis Cloud.
-
-[Install Context Retriever]({{< relref "/develop/ai/context-engine/context-retriever/install" >}})
-
-## Also available on Redis Cloud
-
-All Redis Iris services, including LangCache and Data Integration, are available as fully managed services on Redis Cloud with no infrastructure to set up or maintain.
-
-[Redis Iris on Redis Cloud]({{< relref "/operate/rc/context-engine" >}})
+Deploy supported Redis Iris services on Kubernetes when you need to operate them on your own infrastructure.
diff --git a/content/operate/iris/agent-memory/_index.md b/content/operate/iris/agent-memory/_index.md
new file mode 100644
index 0000000000..ad799fbb96
--- /dev/null
+++ b/content/operate/iris/agent-memory/_index.md
@@ -0,0 +1,30 @@
+---
+title: Redis Agent Memory
+description: Deploy and operate Redis Agent Memory on Redis Cloud or your own infrastructure.
+linkTitle: Redis Agent Memory
+alwaysopen: false
+categories:
+- docs
+- operate
+- iris
+weight: 10
+hideListLinks: true
+aliases:
+- /operate/rc/context-engine/agent-memory/
+---
+
+Redis Agent Memory provides persistent session memory and long-term memory for AI agents and applications.
+
+## Deployment options
+
+### 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" >}})
+
+### 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" >}}) or [view and manage an existing service]({{< relref "/operate/iris/agent-memory/view-service" >}}).
diff --git a/content/operate/rc/context-engine/agent-memory/create-service.md b/content/operate/iris/agent-memory/create-service.md
similarity index 67%
rename from content/operate/rc/context-engine/agent-memory/create-service.md
rename to content/operate/iris/agent-memory/create-service.md
index f5b948583e..69fff0bf6b 100644
--- a/content/operate/rc/context-engine/agent-memory/create-service.md
+++ b/content/operate/iris/agent-memory/create-service.md
@@ -3,57 +3,60 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
-description: Create an Agent Memory service in Redis Cloud to store working and long-term memory for AI agents.
+- iris
+description: Create a Redis Agent Memory service in Redis Cloud to store working and long-term memory for AI agents.
hideListLinks: true
linktitle: Create service
-title: Create an Agent Memory service
+title: Create a Redis Agent Memory service
weight: 5
+bannerText: Redis Agent Memory on Redis Cloud is currently available as a public preview. Features and behavior are subject to change.
+aliases:
+- /operate/rc/context-engine/agent-memory/create-service/
---
-Redis Agent Memory provides a persistent, structured memory layer that AI agents can use to store, retrieve, and manage contextual data across interactions. This guide walks you through creating and configuring an Agent Memory service in Redis Cloud.
+Redis Agent Memory provides a persistent, structured memory layer that AI agents can use to store, retrieve, and manage contextual data across interactions. This guide walks you through creating and configuring a Redis Agent Memory service in Redis Cloud.
## Prerequisites and limitations
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 >}}
-Agent Memory does not support the following databases during public preview:
+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
{{< /note >}}
-## Create an Agent Memory service
+## Create a Redis Agent Memory service
From the [Redis Cloud console](https://cloud.redis.io/), select **Agent Memory** from the left-hand menu.
-If you have not already created an Agent Memory service, you'll see a page with an introduction to Agent Memory. Otherwise, select **New service** to go to the Agent Memory introduction page.
+If you have not already created a Redis Agent Memory service, you'll see a page with an introduction to Redis Agent Memory. Otherwise, select **New service** to go to the Redis Agent Memory introduction page.
{{
}}
From here:
-- Select **Quick create** to create an Agent Memory service with default settings using your Free 30MB database. If you haven't created a Free database yet, Redis Cloud will create one and set up the Agent Memory service for you.
+- Select **Quick create** to create a Redis Agent Memory service with default settings using your Free 30MB database. If you haven't created a Free database yet, Redis Cloud will create one and set up the Redis Agent Memory service for you.
{{}}
- After Redis Cloud creates your Agent Memory service, a window containing your Agent Memory service key will appear. Select **Copy** to copy the key to your clipboard.
+ After Redis Cloud creates your Redis Agent Memory service, a window containing your Redis Agent Memory service key will appear. Select **Copy** to copy the key to your clipboard.
- {{}}
+ {{}}
{{}}
This is the only time the value of the user key is available. Save it to a secure location before closing the dialog box.
-If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/rc/context-engine/agent-memory/view-service#replace-service-api-key" >}}) to be able to use the Agent Memory API.
+If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/iris/agent-memory/view-service#replace-service-api-key" >}}) to be able to use the Redis Agent Memory API.
{{}}
- After Redis Cloud creates your service, [continue with the REST quickstart]({{< relref "/operate/rc/context-engine/agent-memory/use-agent-memory" >}}).
+ After Redis Cloud creates your service, [continue with the REST API quickstart]({{< relref "/develop/ai/context-engine/agent-memory/rest-api-quickstart" >}}).
-- If you want to customize your Agent Memory service, select **Create custom**.
+- If you want to customize your Redis Agent Memory service, select **Create custom**.
- {{}}
+ {{}}
This takes you to the **Create Agent Memory Service** page. This page is divided into the following sections:
@@ -69,9 +72,9 @@ The **General settings** section defines basic properties of your service.
| Setting name |Description|
|:----------------------|:----------|
-| **Service name** | Enter a name for your Agent Memory service. We recommend you use a name that describes your service's purpose. |
+| **Service name** | Enter a name for your Redis Agent Memory service. We recommend you use a name that describes your service's purpose. |
| **Select database** | Select the Redis Cloud database to use for this service from the list. |
-| **User for this service** | The [database access user]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}) to use for this service. Agent Memory only supports the [`default` user]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) during public preview. |
+| **User for this service** | The [database access user]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}) to use for this service. Redis Agent Memory only supports the [`default` user]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) during public preview. |
### Memory configuration
@@ -137,26 +140,45 @@ Each custom memory type can have an **extraction strategy** that controls how th
| **Extraction prompt** | A natural-language prompt (up to 10,000 characters) that instructs the extraction pipeline how to identify and extract this memory type from a conversation. |
| **Enabled** | Whether the extraction strategy is active. Enabled by default. Disable it to keep the type defined without extracting new memories for it. |
+### Sensitive-data exclusions {#sensitive-data-exclusions}
+
+The **Sensitive-data exclusions** section lets you guide automatic extraction away from information that should not be stored in long-term memory. Semantic exclusions can match concepts that a literal pattern might not cover, such as secrets, recovery codes, and similar information.
+
+| Setting name | Description |
+|:-------------|:------------|
+| **Semantic exclusions** | Whether the extraction model applies the exclusion prompt when creating long-term memories from session events. |
+| **Exclusion prompt** | Plain-language instructions describing information that should not be kept in long-term memory. Maximum length: 2,000 characters. |
+
+For example:
+
+```text
+Do not keep passwords, access tokens, recovery codes, payment card information, or booking confirmation codes in long-term memory.
+```
+
+{{< warning >}}
+Sensitive-data exclusions are advisory and do not guarantee that information is excluded. Sensitive session content still reaches the extraction model provider. Exclusions do not apply to long-term memories created directly through the API or an SDK.
+{{< /warning >}}
+
### Create service
-When you are done setting the details of your Agent Memory service, select **Create** to create it.
+When you are done setting the details of your Redis Agent Memory service, select **Create** to create it.
-{{}}
+{{}}
-A window containing your Agent Memory service key will appear. Select **Copy** to copy the key to your clipboard.
+A window containing your Redis Agent Memory service key will appear. Select **Copy** to copy the key to your clipboard.
-{{}}
+{{}}
{{}}
This is the only time the value of the user key is available. Save it to a secure location before closing the dialog box.
-If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/rc/context-engine/agent-memory/view-service#replace-service-api-key" >}}) to be able to use the Agent Memory API.
+If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/iris/agent-memory/view-service#replace-service-api-key" >}}) to be able to use the Redis Agent Memory API.
{{}}
If an error occurs, verify that your database is active. For help, [contact support](https://redis.io/support/).
## Next steps
-After Redis Cloud creates your service, [continue with the REST quickstart]({{< relref "/operate/rc/context-engine/agent-memory/use-agent-memory" >}}).
+After Redis Cloud creates your service, [continue with the REST API quickstart]({{< relref "/develop/ai/context-engine/agent-memory/rest-api-quickstart" >}}).
-You can also [view and edit the service]({{< relref "/operate/rc/context-engine/agent-memory/view-service" >}}).
+You can also [view and edit the service]({{< relref "/operate/iris/agent-memory/view-service" >}}).
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/_index.md b/content/operate/iris/agent-memory/self-managed/_index.md
similarity index 66%
rename from content/develop/ai/context-engine/agent-memory/self-managed/_index.md
rename to content/operate/iris/agent-memory/self-managed/_index.md
index 201174bfa5..9ae637b429 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/_index.md
+++ b/content/operate/iris/agent-memory/self-managed/_index.md
@@ -3,24 +3,26 @@ Title: Self-managed Redis Agent Memory
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Deploy, configure, secure, and operate Redis Agent Memory on a self-managed Kubernetes cluster.
-linkTitle: Self-managed Agent Memory
+linkTitle: Self-managed
weight: 40
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/
---
Redis Agent Memory provides persistent memory for AI agents and
applications. Applications write conversation events and long-term memories to
-Agent Memory, then query Agent Memory for relevant context before calling an LLM.
+Redis Agent Memory, then query Redis Agent Memory for relevant context before calling an LLM.
This guide covers deployment, configuration, security, validation, API examples,
-and operations for self-managed Agent Memory.
+and operations for self-managed Redis Agent Memory.
The [Redis Agent Memory API]({{< relref "/develop/ai/context-engine/agent-memory/api-reference" >}})
is the shared Data Plane API for Redis Cloud and self-managed deployments. The
-[Control Plane API reference]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference" >}})
+[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 >}}
@@ -31,15 +33,15 @@ license key to deploy it. Contact your Redis representative or
## What you are deploying
-A standard self-managed Agent Memory deployment contains:
+A standard self-managed Redis Agent Memory deployment contains:
| Component | Purpose | Default service |
| --- | --- | --- |
-| Agent Memory Data Plane | Store-scoped runtime memory API. | `redis-agent-memory:9000` |
-| Agent Memory worker | Background promotion, summarization, and forgetting work. | No public service |
-| Agent Memory Control Plane | Optional admin API for creating stores and managing agent keys. | `redis-agent-memory-controlplane:9100` |
+| Redis Agent Memory Data Plane | Store-scoped runtime memory API. | `redis-agent-memory:9000` |
+| Redis Agent Memory worker | Background promotion, summarization, and forgetting work. | No public service |
+| Redis Agent Memory Control Plane | Optional admin API for creating stores and managing agent keys. | `redis-agent-memory-controlplane:9100` |
| Store Redis | Holds session memory, long-term memory, indexes, and TTL data. | Customer-provided |
-| Job Redis | Holds background work for Agent Memory workers. | Customer-provided |
+| Job Redis | Holds background work for Redis Agent Memory workers. | Customer-provided |
| Metadata Redis | Holds Control Plane store records and agent-key records. | Required for Control Plane managed stores and agent keys |
### How the components work together
@@ -49,9 +51,9 @@ handles store and agent-key administration.
| Flow | Caller | Service | Backing Redis |
| --- | --- | --- | --- |
-| Store and key administration | Platform admin | Agent Memory Control Plane | Metadata Redis |
-| Runtime memory requests | Agent, app, or gateway | Agent Memory Data Plane | Store Redis |
-| Background memory processing | Agent Memory worker | Agent Memory Data Plane | Job Redis and Store Redis |
+| Store and key administration | Platform admin | Redis Agent Memory Control Plane | Metadata Redis |
+| Runtime memory requests | Agent, app, or gateway | Redis Agent Memory Data Plane | Store Redis |
+| Background memory processing | Redis Agent Memory worker | Redis Agent Memory Data Plane | Job Redis and Store Redis |
1. Platform admins use the Control Plane to create stores and agent keys.
1. The Control Plane stores store records and agent-key grants in Metadata Redis.
@@ -77,21 +79,21 @@ Session memory keeps conversation continuity within a session. Long-term memory
provides searchable context across sessions.
Long-term memory `memoryType` is an open identifier. When omitted on create,
-Agent Memory stores the record as `semantic`; built-in names include `semantic`,
+Redis Agent Memory stores the record as `semantic`; built-in names include `semantic`,
`episodic`, `message`, and `session_summary_view`.
## Deployment modes
-Start with [Plan a deployment]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/plan-deployment" >}})
+Start with [Plan a deployment]({{< relref "/operate/iris/agent-memory/self-managed/plan-deployment" >}})
to choose between static stores and Control Plane managed stores.
| If you need to | Go to |
| --- | --- |
-| Review software, Redis, network, Secret, image, and sizing requirements | [Prerequisites]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/prerequisites" >}}) |
-| Prepare `memory-dataplane.config.yaml` for either deployment mode | [Data Plane configuration]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration" >}}) |
-| Deploy a first-install or single-store setup without the Control Plane | [Deploy with static stores]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/deploy-static" >}}) |
-| Deploy runtime store and agent-key administration | [Deploy with Control Plane managed stores]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/deploy-control-plane" >}}) |
+| Review software, Redis, network, Secret, image, and sizing requirements | [Prerequisites]({{< relref "/operate/iris/agent-memory/self-managed/prerequisites" >}}) |
+| Prepare `memory-dataplane.config.yaml` for either deployment mode | [Data Plane configuration]({{< relref "/operate/iris/agent-memory/self-managed/data-plane-configuration" >}}) |
+| Deploy a first-install or single-store setup without the Control Plane | [Deploy with static stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-static" >}}) |
+| Deploy runtime store and agent-key administration | [Deploy with Control Plane managed stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-control-plane" >}}) |
Do not combine static `metadata.stores` with Control Plane managed store
metadata in the same Data Plane config. Static stores do not use Metadata Redis.
@@ -100,7 +102,7 @@ Redis.
{{< warning >}}
Do not expose an auth-disabled Data Plane to untrusted callers. In auth-disabled
-mode, Agent Memory does not authenticate or authorize Data Plane requests; any caller that
+mode, Redis Agent Memory does not authenticate or authorize Data Plane requests; any caller that
can reach the API can read or write memory for configured stores. Use that mode
only when Kubernetes NetworkPolicy, private service exposure, ingress/gateway
policy, service mesh, or equivalent controls restrict access to trusted
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/api-examples.md b/content/operate/iris/agent-memory/self-managed/api-examples.md
similarity index 92%
rename from content/develop/ai/context-engine/agent-memory/self-managed/api-examples.md
rename to content/operate/iris/agent-memory/self-managed/api-examples.md
index 0cb05abd8a..d4efc28457 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/api-examples.md
+++ b/content/operate/iris/agent-memory/self-managed/api-examples.md
@@ -3,23 +3,25 @@ Title: Self-managed API examples
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Use curl examples with the Redis Agent Memory self-managed Control Plane and Data Plane APIs.
linkTitle: Self-managed API examples
weight: 70
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/api-examples/
---
These examples show self-managed Control Plane and Data Plane requests.
They assume either an auth-disabled private Data Plane or agent-key auth
-configured as described in [Authentication and authorization]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/authentication" >}}).
+configured as described in [Authentication and authorization]({{< relref "/operate/iris/agent-memory/self-managed/authentication" >}}).
For the complete shared Data Plane schema, see the
[Redis Agent Memory API]({{< relref "/develop/ai/context-engine/agent-memory/api-reference" >}}).
For the self-managed admin schema, see the
-[Control Plane API reference]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference" >}}).
+[Control Plane API reference]({{< relref "/operate/iris/agent-memory/self-managed/control-plane-api-reference" >}}).
## Control Plane API examples
@@ -136,7 +138,7 @@ Request body fields:
| `role` | Required. Use `USER`, `ASSISTANT`, or `SYSTEM`. |
| `content` | Required. For text, use a content object such as `{"text": "..."}`. |
| `createdAt` | Required. Use an RFC 3339 timestamp, for example `2026-06-25T18:00:00Z`. |
-| `sessionId` | Optional. If omitted, Agent Memory generates one. |
+| `sessionId` | Optional. If omitted, Redis Agent Memory generates one. |
### Read session memory
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/authentication.md b/content/operate/iris/agent-memory/self-managed/authentication.md
similarity index 81%
rename from content/develop/ai/context-engine/agent-memory/self-managed/authentication.md
rename to content/operate/iris/agent-memory/self-managed/authentication.md
index 87823aba56..ff75435fc6 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/authentication.md
+++ b/content/operate/iris/agent-memory/self-managed/authentication.md
@@ -3,20 +3,22 @@ Title: Authentication and authorization
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Configure Redis Agent Memory self-managed Control Plane authentication, Data Plane auth modes, worker callbacks, and gateway integration.
linkTitle: Authentication and authorization
weight: 60
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/authentication/
---
-Self-managed Agent Memory uses separate authentication models for the Control
+Self-managed Redis Agent Memory uses separate authentication models for the Control
Plane and Data Plane.
The Control Plane uses an admin token for management endpoints. The Data Plane
-can run behind infrastructure controls with Agent Memory auth disabled, or it
-can validate Agent Memory agent keys and enforce store-level grants.
+can run behind infrastructure controls with Redis Agent Memory auth disabled, or it
+can validate Redis Agent Memory agent keys and enforce store-level grants.
## Control Plane admin token
@@ -47,7 +49,7 @@ Choose the Data Plane auth mode based on how callers reach the Data Plane.
| Mode | Config | Use when |
| --- | --- | --- |
| Auth-disabled Data Plane | `auth.method: none` | The Data Plane is reachable only by trusted internal components. |
-| Agent-key authentication | `auth.method: agent_key` | Agent Memory should validate keys and enforce per-store grants. |
+| Agent-key authentication | `auth.method: agent_key` | Redis Agent Memory should validate keys and enforce per-store grants. |
### Auth-disabled Data Plane
@@ -61,7 +63,7 @@ components.
{{< warning >}}
Do not expose an auth-disabled Data Plane to untrusted callers. In auth-disabled
-mode, Agent Memory does not authenticate or authorize Data Plane requests; any
+mode, Redis Agent Memory does not authenticate or authorize Data Plane requests; any
caller that can reach the API can read or write memory for configured stores.
{{< /warning >}}
@@ -79,7 +81,7 @@ Starting from static store configuration, make these changes:
4. Add the `embedding` selection block.
5. Keep `embedders_connection_details` for the embedder endpoint and
credentials.
-6. If Agent Memory workers are enabled, configure worker identity as described in
+6. If Redis Agent Memory workers are enabled, configure worker identity as described in
[Worker callbacks](#worker-callbacks) so worker-to-Data Plane calls carry an
accepted credential.
@@ -120,7 +122,7 @@ embedders_connection_details:
queue_size: 1000
```
-When the Data Plane uses `metadata.source: live`, Agent Memory defaults to
+When the Data Plane uses `metadata.source: live`, Redis Agent Memory defaults to
`auth.method: agent_key` when no auth method is configured. Set it explicitly in
production values so the intended security posture is visible in review. If
agent-key auth is enabled without `metadata.source: live`, the Data Plane fails
@@ -136,7 +138,7 @@ Treat agent keys as opaque credentials. Do not parse their contents.
## Store authorization and grants
-For agent-key requests, Agent Memory checks both identity and resource
+For agent-key requests, Redis Agent Memory checks both identity and resource
authorization:
1. The key exists in metadata Redis and its secret validates.
@@ -161,10 +163,10 @@ Operation mapping:
## Worker callbacks
-Agent Memory workers consume background jobs and call the Data Plane to read
+Redis Agent Memory workers consume background jobs and call the Data Plane to read
session events and write extracted long-term memories.
-For deployments where Agent Memory Data Plane auth is enabled, workers should
+For deployments where Redis Agent Memory Data Plane auth is enabled, workers should
authenticate with Kubernetes projected service-account tokens. The Helm
`workerAuth.enabled` preset creates or uses a worker ServiceAccount and mounts a
projected token into the worker pod. The Data Plane must also be configured to
@@ -223,7 +225,7 @@ Configure worker identity to:
- Trust one or more exact Kubernetes service-account subjects.
- Validate worker tokens by issuer, JWKS URI, audience, and signing algorithm.
-- Map each trusted subject to an Agent Memory `Principal` with roles, scopes,
+- Map each trusted subject to a Redis Agent Memory `Principal` with roles, scopes,
and resource grants.
- Grant store access with resource keys such as `mem-store:`.
- Use `mem-store:*` for a shared worker identity, or use narrower store grants
@@ -232,7 +234,7 @@ Configure worker identity to:
`write`.
The Helm ServiceAccount/token settings only provide the Kubernetes credential.
-Agent Memory authorization still comes from the server-side
+Redis Agent Memory authorization still comes from the server-side
`auth.worker_identity` subject grants. If worker auth is not configured, keep
the Data Plane auth-disabled and reachable only by trusted internal components.
@@ -240,7 +242,7 @@ the Data Plane auth-disabled and reachable only by trusted internal components.
Use a gateway when it owns external authentication and coarse policy. For
example, a gateway can authenticate callers through an identity provider before
-it forwards requests to Agent Memory.
+it forwards requests to Redis Agent Memory.
If the gateway also owns the standard `Authorization` header, forward the Agent
Memory key in `X-Api-Key`:
@@ -250,15 +252,15 @@ Authorization: Bearer
X-Api-Key:
```
-Agent Memory uses `X-Api-Key` as the Agent Memory credential when present. The
-gateway token is still available to the gateway, but Agent Memory authorizes the
-request from the server-side grants attached to the Agent Memory key.
+Redis Agent Memory uses `X-Api-Key` as the Redis Agent Memory credential when present. The
+gateway token is still available to the gateway, but Redis Agent Memory authorizes the
+request from the server-side grants attached to the Redis Agent Memory key.
Gateway rules:
- The gateway owns external authentication and perimeter policy.
-- Agent Memory owns store-level authorization.
-- Agent Memory keys are stored and forwarded by trusted infrastructure or
+- Redis Agent Memory owns store-level authorization.
+- Redis Agent Memory keys are stored and forwarded by trusted infrastructure or
trusted applications.
- Callers must not be able to bypass the gateway and reach the Data Plane
- directly unless they also present a valid Agent Memory credential.
+ directly unless they also present a valid Redis Agent Memory credential.
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference.md b/content/operate/iris/agent-memory/self-managed/control-plane-api-reference.md
similarity index 71%
rename from content/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference.md
rename to content/operate/iris/agent-memory/self-managed/control-plane-api-reference.md
index a79f0687a0..c8e986bf93 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference.md
+++ b/content/operate/iris/agent-memory/self-managed/control-plane-api-reference.md
@@ -4,6 +4,8 @@ linkTitle: Control Plane API reference
layout: apireference
type: page
weight: 80
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference/
params:
sourcefile: ./openapi-control-plane.json
sortOperationsAlphabetically: false
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference/openapi-control-plane.json b/content/operate/iris/agent-memory/self-managed/control-plane-api-reference/openapi-control-plane.json
similarity index 100%
rename from content/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference/openapi-control-plane.json
rename to content/operate/iris/agent-memory/self-managed/control-plane-api-reference/openapi-control-plane.json
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration.md b/content/operate/iris/agent-memory/self-managed/data-plane-configuration.md
similarity index 92%
rename from content/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration.md
rename to content/operate/iris/agent-memory/self-managed/data-plane-configuration.md
index f5d79e7544..e1151b0287 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration.md
+++ b/content/operate/iris/agent-memory/self-managed/data-plane-configuration.md
@@ -3,12 +3,14 @@ Title: Data Plane configuration
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Configure the Redis Agent Memory Data Plane for static stores or Control Plane managed stores.
linkTitle: Data Plane configuration
weight: 30
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration/
---
The Data Plane reads `memory-dataplane.config.yaml` from a Kubernetes Secret.
@@ -169,8 +171,8 @@ promote_session_memory:
```
This Control Plane managed example leaves Data Plane auth disabled at the Agent
-Memory layer. To use Agent Memory agent keys, set `auth.method: agent_key` and
-follow [Authentication and authorization]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/authentication" >}}).
+Memory layer. To use Redis Agent Memory agent keys, set `auth.method: agent_key` and
+follow [Authentication and authorization]({{< relref "/operate/iris/agent-memory/self-managed/authentication" >}}).
## Secret key
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/deploy-control-plane.md b/content/operate/iris/agent-memory/self-managed/deploy-control-plane.md
similarity index 90%
rename from content/develop/ai/context-engine/agent-memory/self-managed/deploy-control-plane.md
rename to content/operate/iris/agent-memory/self-managed/deploy-control-plane.md
index 04f871bd08..99c0fbdc2b 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/deploy-control-plane.md
+++ b/content/operate/iris/agent-memory/self-managed/deploy-control-plane.md
@@ -3,23 +3,24 @@ Title: Deploy with Control Plane managed stores
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Deploy Redis Agent Memory with stores managed by the self-managed Control Plane.
linkTitle: Deploy with Control Plane managed stores
weight: 50
hideListLinks: true
aliases:
- /develop/ai/context-engine/agent-memory/self-managed/control-plane/
+- /develop/ai/context-engine/agent-memory/self-managed/deploy-control-plane/
---
Use Control Plane managed stores when operators need to create stores or agent
keys at runtime. In this mode, the Data Plane reads store and agent-key records
from Metadata Redis.
-Before you begin, review [prerequisites]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/prerequisites" >}})
+Before you begin, review [prerequisites]({{< relref "/operate/iris/agent-memory/self-managed/prerequisites" >}})
and create `memory-dataplane.config.yaml` from the
-[Control Plane managed stores example]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration#control-plane-managed-stores-example" >}}).
+[Control Plane managed stores example]({{< relref "/operate/iris/agent-memory/self-managed/data-plane-configuration#control-plane-managed-stores-example" >}}).
## Create the namespace
@@ -226,7 +227,7 @@ curl -H "Authorization: Bearer " \
```
For the full self-managed admin API schema, see the
-[Control Plane API reference]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference" >}}).
+[Control Plane API reference]({{< relref "/operate/iris/agent-memory/self-managed/control-plane-api-reference" >}}).
After you deploy Control Plane managed stores, configure Data Plane auth in
-[Authentication and authorization]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/authentication" >}}).
+[Authentication and authorization]({{< relref "/operate/iris/agent-memory/self-managed/authentication" >}}).
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/deploy-static.md b/content/operate/iris/agent-memory/self-managed/deploy-static.md
similarity index 91%
rename from content/develop/ai/context-engine/agent-memory/self-managed/deploy-static.md
rename to content/operate/iris/agent-memory/self-managed/deploy-static.md
index 77f67c0df9..40048f66c6 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/deploy-static.md
+++ b/content/operate/iris/agent-memory/self-managed/deploy-static.md
@@ -3,23 +3,24 @@ Title: Deploy with static stores
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Deploy Redis Agent Memory with static stores and no Control Plane.
linkTitle: Deploy with static stores
weight: 40
hideListLinks: true
aliases:
- /develop/ai/context-engine/agent-memory/self-managed/install-k8s/
+- /develop/ai/context-engine/agent-memory/self-managed/deploy-static/
---
Use static stores for a first install or a private single-store deployment. In
this mode, stores are declared directly in Data Plane configuration. The
deployment does not include the Control Plane and does not use Metadata Redis.
-Before you begin, review [prerequisites]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/prerequisites" >}})
+Before you begin, review [prerequisites]({{< relref "/operate/iris/agent-memory/self-managed/prerequisites" >}})
and create `memory-dataplane.config.yaml` from the
-[static stores example]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/data-plane-configuration#static-stores-example" >}}).
+[static stores example]({{< relref "/operate/iris/agent-memory/self-managed/data-plane-configuration#static-stores-example" >}}).
## Create the namespace
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/operations.md b/content/operate/iris/agent-memory/self-managed/operations.md
similarity index 90%
rename from content/develop/ai/context-engine/agent-memory/self-managed/operations.md
rename to content/operate/iris/agent-memory/self-managed/operations.md
index b081265e4f..4997f92a4e 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/operations.md
+++ b/content/operate/iris/agent-memory/self-managed/operations.md
@@ -3,12 +3,14 @@ Title: Operations
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Operate Redis Agent Memory with backups, secret rotation, updates, FIPS posture, and network policy.
linkTitle: Operations
weight: 90
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/operations/
---
## Backups
@@ -28,7 +30,7 @@ hideListLinks: true
## Secret rotation
-Rotate Agent Memory agent keys through the Control Plane API:
+Rotate Redis Agent Memory agent keys through the Control Plane API:
```bash
curl -sS -X POST "$CP_URL/v1/api-keys//rotate" \
@@ -49,9 +51,9 @@ kubectl -n create secret generic ram-controlplane-admin-token \
-o yaml | kubectl apply -f -
```
-Rotate the Agent Memory license by updating the license Secret and changing
+Rotate the Redis Agent Memory license by updating the license Secret and changing
`license.existingSecretChecksum` so Helm rolls the Data Plane and worker pods.
-Agent Memory reads and validates the license file during process startup; updating only
+Redis Agent Memory reads and validates the license file during process startup; updating only
the Secret data is not sufficient.
```bash
@@ -194,10 +196,10 @@ When the posture is active, the Data Plane and worker reject config that:
The Control Plane runs under the same posture and rejects non-`rediss://`
`metadata.urls` or `store_db.urls`.
-The Agent Memory API listener itself speaks HTTP inside the cluster. Edge TLS termination
+The Redis Agent Memory API listener itself speaks HTTP inside the cluster. Edge TLS termination
is owned by the hosting environment, such as ingress, service mesh, or external
load balancer. Outbound TLS to Redis, embedding providers, LLM providers, and
-worker callback endpoints is configured through Agent Memory config and is covered by the
+worker callback endpoints is configured through Redis Agent Memory config and is covered by the
posture checks.
Verify the runtime posture with:
@@ -216,7 +218,7 @@ override the container command to configure it.
For auth-disabled Data Plane deployments, restrict access to trusted callers.
For agent-key deployments behind a gateway, prevent direct bypass paths unless
-the direct caller also has a valid Agent Memory credential.
+the direct caller also has a valid Redis Agent Memory credential.
The chart includes `deployment/redis-agent-memory/networkpolicy.reference.yaml`
as a reference manifest. It is not templated because allowed callers are
@@ -224,15 +226,15 @@ environment-specific.
Customize the placeholders before applying it:
-- ``: namespace where Agent Memory is installed.
+- ``: namespace where Redis Agent Memory is installed.
- `redis-agent-memory`: Helm release name used in this guide. If you use a
different release name, update release-derived service and deployment names.
`nameOverride` and `fullnameOverride` change rendered resource names, but the
`app.kubernetes.io/instance` selector remains the Helm release name.
- `` and caller pod labels: ingress controller, service mesh
- gateway, application pod, or approved internal caller allowed to call Agent Memory.
+ gateway, application pod, or approved internal caller allowed to call Redis Agent Memory.
-The reference policy default-denies ingress to Agent Memory chart pods, then allows TCP
+The reference policy default-denies ingress to Redis Agent Memory chart pods, then allows TCP
traffic to server pods on port `9000` from approved callers and the worker
Deployment. It also includes a Control Plane stanza for port `9100` when
`controlplane.enabled=true`. Review the manifest against the customer's CNI,
diff --git a/content/operate/iris/agent-memory/self-managed/plan-deployment.md b/content/operate/iris/agent-memory/self-managed/plan-deployment.md
new file mode 100644
index 0000000000..7009d5f620
--- /dev/null
+++ b/content/operate/iris/agent-memory/self-managed/plan-deployment.md
@@ -0,0 +1,46 @@
+---
+Title: Plan a self-managed Redis Agent Memory deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- iris
+description: Choose a self-managed Redis Agent Memory deployment mode before installing the Helm chart.
+linkTitle: Plan a deployment
+weight: 10
+hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/plan-deployment/
+---
+
+Choose the deployment mode before you create Redis databases, configuration
+Secrets, or Helm values.
+
+## Deployment modes
+
+{{< table-scrollable >}}
+| Mode | What it deploys | Redis databases | Data Plane auth | Start here |
+| --- | --- | --- | --- | --- |
+| Static stores | Data Plane and, when enabled, Redis Agent Memory workers. Stores are declared directly in `memory-dataplane.config.yaml`. | Store Redis. Job Redis when workers are enabled. | Disabled at the Redis Agent Memory layer. Protect access with Kubernetes, ingress, gateway, or service-mesh controls. | [Deploy with static stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-static" >}}) |
+| Control Plane managed stores | Data Plane, Control Plane, and, when enabled, Redis Agent Memory workers. Stores and agent keys are managed at runtime. | Store Redis, Metadata Redis, and Job Redis when workers are enabled. | Auth-disabled Data Plane or Redis Agent Memory agent keys. | [Deploy with Control Plane managed stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-control-plane" >}}) |
+{{< /table-scrollable >}}
+
+## Mode rules
+
+Do not combine static `metadata.stores` with Control Plane managed store
+metadata in the same Data Plane config. Static stores do not use Metadata Redis.
+Control Plane managed stores use `metadata.source: live` and require Metadata
+Redis.
+
+Agent-key authentication requires Control Plane managed stores because the Data
+Plane reads agent-key records and store grants from Metadata Redis.
+
+The walkthroughs in this section use `redis-agent-memory` as the Helm release
+name. If you choose a different release name, update release-derived service and
+deployment names in the verification commands.
+
+## Before you deploy
+
+1. Review [prerequisites]({{< relref "/operate/iris/agent-memory/self-managed/prerequisites" >}}).
+1. Prepare the appropriate [Data Plane configuration]({{< relref "/operate/iris/agent-memory/self-managed/data-plane-configuration" >}}).
+1. Follow either [Deploy with static stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-static" >}}) or [Deploy with Control Plane managed stores]({{< relref "/operate/iris/agent-memory/self-managed/deploy-control-plane" >}}).
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/prerequisites.md b/content/operate/iris/agent-memory/self-managed/prerequisites.md
similarity index 84%
rename from content/develop/ai/context-engine/agent-memory/self-managed/prerequisites.md
rename to content/operate/iris/agent-memory/self-managed/prerequisites.md
index cc6fd75198..6d4b24b1ca 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/prerequisites.md
+++ b/content/operate/iris/agent-memory/self-managed/prerequisites.md
@@ -1,25 +1,27 @@
---
-Title: Self-managed Agent Memory prerequisites
+Title: Self-managed Redis Agent Memory prerequisites
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Review software, Redis, network, Secret, image, and sizing prerequisites for self-managed Redis Agent Memory.
linkTitle: Prerequisites
weight: 20
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/prerequisites/
---
Redis Agent Memory is distributed as container images on Docker Hub plus a Helm
-chart in the Redis AI Helm repository. The chart deploys the Agent Memory Data
-Plane, Agent Memory workers, and optionally the Agent Memory Control Plane.
+chart in the Redis AI Helm repository. The chart deploys the Redis Agent Memory Data
+Plane, Redis Agent Memory workers, and optionally the Redis Agent Memory Control Plane.
You provide the Redis databases, provider credentials, Kubernetes exposure, and
license material used by the deployment.
{{< note >}}
-This guide is for system administrators deploying Agent Memory on a self-managed
+This guide is for system administrators deploying Redis Agent Memory on a self-managed
Kubernetes cluster.
{{< /note >}}
@@ -44,11 +46,11 @@ Kubernetes cluster.
## Redis databases
The Helm chart does not deploy Redis databases. Provision the Redis databases
-outside the Agent Memory chart and pass their URLs in
+outside the Redis Agent Memory chart and pass their URLs in
`memory-dataplane.config.yaml` and, when the Control Plane is enabled,
`controlplane-onprem.config.yaml`.
-Store Redis must support Search and JSON capabilities because Agent Memory
+Store Redis must support Search and JSON capabilities because Redis Agent Memory
creates JSON and vector search indexes for memory data. Job Redis and Metadata
Redis do not need those capabilities when they are deployed as separate Redis
databases.
@@ -110,7 +112,7 @@ Plane store records and agent-key records.
`docker.io` and reach the Redis AI Helm repository.
- **Air-gapped install:** mirror the images into an internal registry and use a
chart package or locally downloaded chart.
-- **Runtime access:** Agent Memory pods must reach the Redis databases and any
+- **Runtime access:** Redis Agent Memory pods must reach the Redis databases and any
embedding or LLM provider endpoints used by the deployment.
- **Data Plane exposure:** use NetworkPolicy, ingress, gateway, service mesh,
private load balancer, or equivalent controls to restrict API access.
@@ -121,8 +123,8 @@ The chart consumes configuration and license material from Kubernetes Secrets:
| Secret | Required when | Default key |
| --- | --- | --- |
-| Agent Memory license Secret | Always | `license` |
-| Agent Memory Data Plane config Secret | Always | `memory-dataplane.config.yaml` |
+| Redis Agent Memory license Secret | Always | `license` |
+| Redis Agent Memory Data Plane config Secret | Always | `memory-dataplane.config.yaml` |
| Control Plane config Secret | Control Plane enabled | `controlplane-onprem.config.yaml` |
| Control Plane admin-token Secret | Control Plane enabled | `token` |
@@ -131,7 +133,7 @@ keys and Redis URLs may include credentials.
## Release artifacts and image tags
-Agent Memory self-managed image tags use the release SemVer value, for example:
+Redis Agent Memory self-managed image tags use the release SemVer value, for example:
```yaml
image:
@@ -145,7 +147,7 @@ Use the chart version supplied by Redis for the release. The published chart is
`redis-ai/redis-agent-memory` from `https://helm.redis.io/ai`.
Standard customer installs use the public Docker Hub images published by the
-Agent Memory self-managed release: `docker.io/redislabs/agent-memory:`
+Redis Agent Memory self-managed release: `docker.io/redislabs/agent-memory:`
and, when the Control Plane is enabled,
`docker.io/redislabs/agent-memory-control-plane:`.
@@ -206,9 +208,9 @@ Default chart values:
| Component | Default | Purpose |
| --------- | ------- | ------- |
-| Agent Memory server | 2 replicas with autoscaling enabled and a minimum of 2 | Data Plane API traffic |
-| Agent Memory worker | 2 replicas with autoscaling enabled and a minimum of 2 | Background promotion, summarization, and forgetting jobs |
-| Agent Memory Control Plane | 1 replica when `controlplane.enabled=true` | Admin API for stores and agent keys |
+| Redis Agent Memory server | 2 replicas with autoscaling enabled and a minimum of 2 | Data Plane API traffic |
+| Redis Agent Memory worker | 2 replicas with autoscaling enabled and a minimum of 2 | Background promotion, summarization, and forgetting jobs |
+| Redis Agent Memory Control Plane | 1 replica when `controlplane.enabled=true` | Admin API for stores and agent keys |
During a rolling update, Kubernetes may temporarily run old and new pods at the
same time. A small two-node test cluster can run out of CPU during install or
@@ -247,10 +249,10 @@ release name.
| API server capacity | `server.resources`, `server.autoscaling.*` | Tuning request capacity or memory footprint. |
| Worker capacity | `worker.resources`, `worker.autoscaling.*` | Tuning background job throughput. |
| Scheduling | `server.nodeSelector`, `worker.nodeSelector`, `server.affinity`, `worker.affinity`, `server.tolerations`, `worker.tolerations` | Controlling pod placement. |
-| Networking | `service.type`, `ingress.*` | Exposing Agent Memory outside the cluster. |
-| Naming | `fullnameOverride` | Running more than one Agent Memory release in a namespace. |
+| Networking | `service.type`, `ingress.*` | Exposing Redis Agent Memory outside the cluster. |
+| Naming | `fullnameOverride` | Running more than one Redis Agent Memory release in a namespace. |
| Service account | `serviceAccount.*` | Matching customer namespace security policy. |
-| Worker authentication | `workerAuth.enabled`, `worker.serviceAccount.*`, `worker.serviceAccount.token.*` | Giving Agent Memory workers a Kubernetes projected service-account token for authenticated Data Plane callbacks. |
+| Worker authentication | `workerAuth.enabled`, `worker.serviceAccount.*`, `worker.serviceAccount.token.*` | Giving Redis Agent Memory workers a Kubernetes projected service-account token for authenticated Data Plane callbacks. |
| Secret rollouts | `license.existingSecretChecksum`, `config.existingSecretChecksum`, `controlplane.config.existingSecretChecksum` | Rolling pods after externally managed Secret changes. |
| Control Plane | `controlplane.enabled`, `controlplane.image.*`, `controlplane.config.existingSecret`, `controlplane.adminToken.*` | Enabling the optional admin API for stores and agent keys. |
{{< /table-scrollable >}}
diff --git a/content/develop/ai/context-engine/agent-memory/self-managed/reference.md b/content/operate/iris/agent-memory/self-managed/reference.md
similarity index 88%
rename from content/develop/ai/context-engine/agent-memory/self-managed/reference.md
rename to content/operate/iris/agent-memory/self-managed/reference.md
index 92a466f68a..95bb708b72 100644
--- a/content/develop/ai/context-engine/agent-memory/self-managed/reference.md
+++ b/content/operate/iris/agent-memory/self-managed/reference.md
@@ -3,12 +3,14 @@ Title: Configuration and troubleshooting
alwaysopen: false
categories:
- docs
-- develop
-- ai
+- operate
+- iris
description: Review self-managed Redis Agent Memory configuration, troubleshooting guidance, and reference links.
linkTitle: Configuration and troubleshooting
weight: 100
hideListLinks: true
+aliases:
+- /develop/ai/context-engine/agent-memory/self-managed/reference/
---
## Configuration reference
@@ -20,7 +22,7 @@ Use these files to configure a self-managed deployment:
| `ram-values.yaml` | Helm values for images, replicas, services, Secret names, and optional Control Plane settings. |
| `memory-dataplane.config.yaml` | Data Plane stores, Redis URLs, auth mode, embedding provider, and worker callback settings. |
| `controlplane-onprem.config.yaml` | Control Plane metadata Redis, store Redis, admin-token auth, and embedding settings. |
-| `license` | Agent Memory license file provided by Redis. |
+| `license` | Redis Agent Memory license file provided by Redis. |
### External secret managers
@@ -29,7 +31,7 @@ admin-token material to the chart as Kubernetes Secrets and set the chart's
`existingSecret` values to those Secret names.
Direct CSI file mounts that bypass Kubernetes Secrets are not supported for the
-Agent Memory license, Data Plane config, Control Plane config, or Control Plane
+Redis Agent Memory license, Data Plane config, Control Plane config, or Control Plane
admin-token paths.
For Secrets Store CSI Driver, use sync-to-Kubernetes-Secret
@@ -44,7 +46,7 @@ CSI-synced Secrets, make sure a Control Plane pod also mounts the corresponding
| --- | --- | --- |
| `helm search repo redis-ai/redis-agent-memory --versions` returns no results | Helm repo not added/updated, or the chart version has not been published to the repo yet | Run `helm repo add`, `helm repo update`, or install from the chart package provided by Redis. |
| Docker pull fails for the configured image tag | Image tag is wrong or has not been published to the configured registry | Use the image tag listed for the release on Docker Hub or provided by Redis. |
-| Pod is stuck in `ImagePullBackOff` or `ErrImagePull` | Cluster cannot pull the configured image, image tag is wrong, registry requires credentials, or `imagePullSecrets` is missing/wrong | Verify `image.repository`, `image.tag`, registry reachability, and `imagePullSecrets`; use the Agent Memory release image tag. |
+| Pod is stuck in `ImagePullBackOff` or `ErrImagePull` | Cluster cannot pull the configured image, image tag is wrong, registry requires credentials, or `imagePullSecrets` is missing/wrong | Verify `image.repository`, `image.tag`, registry reachability, and `imagePullSecrets`; use the Redis Agent Memory release image tag. |
| `helm install --atomic --wait` times out and rolls back | Cluster is small or image pull/startup takes longer than Helm's default timeout | Install without `--atomic --wait`, or set a longer `--timeout` and ensure enough cluster capacity. |
| Pods are pending during install or upgrade | CPU/memory capacity is insufficient for default replicas and rollout overlap | Add nodes/headroom or lower replicas for test deployments. |
| Data Plane health fails | Pod not ready, config invalid, Redis unavailable, or license invalid | Check pod logs and call `/health`, `/health/liveness`, and `/health/readiness`. |
@@ -68,6 +70,6 @@ CSI-synced Secrets, make sure a Control Plane pod also mounts the corresponding
| FIPS values overlay | `deployment/redis-agent-memory/values-fips.yaml` |
| NetworkPolicy reference | `deployment/redis-agent-memory/networkpolicy.reference.yaml` |
| Redis Agent Memory API reference | [Redis Agent Memory API]({{< relref "/develop/ai/context-engine/agent-memory/api-reference" >}}) |
-| Control Plane API reference | [Control Plane API reference]({{< relref "/develop/ai/context-engine/agent-memory/self-managed/control-plane-api-reference" >}}) |
-| Agent Memory Data Plane image tags | [Docker Hub: redislabs/agent-memory](https://hub.docker.com/r/redislabs/agent-memory/tags) |
-| Agent Memory Control Plane image tags | [Docker Hub: redislabs/agent-memory-control-plane](https://hub.docker.com/r/redislabs/agent-memory-control-plane/tags) |
+| Control Plane API reference | [Control Plane API reference]({{< relref "/operate/iris/agent-memory/self-managed/control-plane-api-reference" >}}) |
+| Redis Agent Memory Data Plane image tags | [Docker Hub: redislabs/agent-memory](https://hub.docker.com/r/redislabs/agent-memory/tags) |
+| Redis Agent Memory Control Plane image tags | [Docker Hub: redislabs/agent-memory-control-plane](https://hub.docker.com/r/redislabs/agent-memory-control-plane/tags) |
diff --git a/content/operate/rc/context-engine/agent-memory/view-service.md b/content/operate/iris/agent-memory/view-service.md
similarity index 62%
rename from content/operate/rc/context-engine/agent-memory/view-service.md
rename to content/operate/iris/agent-memory/view-service.md
index 7e8990ea5f..b647b400b9 100644
--- a/content/operate/rc/context-engine/agent-memory/view-service.md
+++ b/content/operate/iris/agent-memory/view-service.md
@@ -3,55 +3,58 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
-description: View and manage your Agent Memory service in Redis Cloud.
+- iris
+description: View and manage your Redis Agent Memory service in Redis Cloud.
hideListLinks: true
linktitle: View service
-title: View and manage Agent Memory service
+title: View and manage Redis Agent Memory service
weight: 15
+bannerText: Redis Agent Memory on Redis Cloud is currently available as a public preview. Features and behavior are subject to change.
+aliases:
+- /operate/rc/context-engine/agent-memory/view-service/
---
-After you have [created your first Agent Memory service]({{< relref "/operate/rc/context-engine/agent-memory/create-service" >}}), selecting **Agent Memory** from the Redis Cloud Console menu will take you to the **Agent Memory Services** page.
+After you have [created your first Redis Agent Memory service]({{< relref "/operate/iris/agent-memory/create-service" >}}), selecting **Agent Memory** from the Redis Cloud Console menu will take you to the **Agent Memory Services** page.
-This page displays a list of all Agent Memory services associated with your account.
+This page displays a list of all Redis Agent Memory services associated with your account.
-{{}}
+{{}}
-Select your Agent Memory service from the list to view the service's details.
+Select your Redis Agent Memory service from the list to view the service's details.
## Configuration tab
-The **Configuration** tab lets you view the details of your Agent Memory service. It contains the following sections:
+The **Configuration** tab lets you view the details of your Redis Agent Memory service. It contains the following sections:
-- The **General settings** section provides the connection details and general settings for your Agent Memory service.
-- The **Memory configuration** section provides the service settings for your Agent Memory service.
+- The **General settings** section provides the connection details and general settings for your Redis Agent Memory service.
+- The **Memory configuration** section provides the service settings for your Redis Agent Memory service.
- The **Memory types & extraction** section shows any custom memory types defined for your service.
-- The **Actions** section lets you flush or delete your Agent Memory service.
+- The **Actions** section lets you flush or delete your Redis Agent Memory service.
Some of these settings can be changed after service creation. To do so, select the **Edit** button.
### General settings
-The **General settings** section provides the connection details and general settings for your Agent Memory service.
+The **General settings** section provides the connection details and general settings for your Redis Agent Memory service.
-{{}}
+{{}}
| Setting name |Description|
|:----------------------|:----------|
| **Service name** | The name of your agent memory service. _(Editable)_ |
| **Database** | The name of the database your service uses. |
-| **Store ID** | The unique ID of your Agent Memory store. |
-| **Endpoint** | The base URL for any Agent Memory requests. |
+| **Store ID** | The unique ID of your Redis Agent Memory store. |
+| **Endpoint** | The base URL for any Redis Agent Memory requests. |
Select the **Copy** button next to the Store ID and API Base URL to copy them to the clipboard.
-Follow the [Redis Cloud Agent Memory REST quickstart]({{< relref "/operate/rc/context-engine/agent-memory/use-agent-memory" >}}) to use the connection information and API key.
+Follow the [Redis Agent Memory REST API quickstart]({{< relref "/develop/ai/context-engine/agent-memory/rest-api-quickstart" >}}) to use the connection information and API key.
### Memory configuration
The **Memory configuration** section shows the time-to-live (TTL) for memory storage, the extraction cadence, and the automatic summarization settings for session memory.
-{{}}
+{{}}
| Setting name |Description|
|:----------------------|:----------|
@@ -64,9 +67,9 @@ The **Memory configuration** section shows the time-to-live (TTL) for memory sto
### Memory types & extraction {#memory-types-and-extraction}
-The **Memory types & extraction** section shows any [custom memory types]({{< relref "/operate/rc/context-engine/agent-memory/create-service#custom-memory-types" >}}) defined for the service, each listed with its name, fields, and extraction strategy.
+The **Memory types & extraction** section shows any [custom memory types]({{< relref "/operate/iris/agent-memory/create-service#custom-memory-types" >}}) defined for the service, each listed with its name, fields, and extraction strategy.
-{{}}
+{{}}
#### Custom memory types
@@ -81,11 +84,22 @@ Because a custom memory type's structure is fixed after creation, only some sett
To change a custom memory type's name or fields, you must create a new service. You can, however, add a new custom memory type when editing the service, up to the limit of 3 custom memory types.
+### Sensitive-data exclusions {#sensitive-data-exclusions}
+
+The **Sensitive-data exclusions** section shows whether semantic exclusions are enabled and the prompt used to guide automatic extraction away from sensitive information.
+
+| Setting name | Description |
+|:-------------|:------------|
+| **Semantic exclusions** | Whether the exclusion prompt is applied during automatic extraction. _(Editable)_ |
+| **Exclusion prompt** | Plain-language instructions describing information that should not be kept in long-term memory. _(Editable)_ |
+
+Sensitive-data exclusions are advisory. They do not guarantee exclusion, sensitive session content still reaches the extraction model provider, and the prompt does not apply to directly created long-term memories.
+
### Actions
-The **Actions** section lets you flush or delete your Agent Memory service.
+The **Actions** section lets you flush or delete your Redis Agent Memory service.
-{{}}
+{{}}
#### Flush memory entries
@@ -101,9 +115,9 @@ Flushing the service is permanent and cannot be undone, and will result in empty
#### Delete service
-Deleting your Agent Memory service permanently deletes all associated memory data, the service configuration, and the Agent Memory search index. It also immediately terminates all API keys associated with the service. Data stored in other indexes within the same database will remain unaffected.
+Deleting your Redis Agent Memory service permanently deletes all associated memory data, the service configuration, and the Redis Agent Memory search index. It also immediately terminates all API keys associated with the service. Data stored in other indexes within the same database will remain unaffected.
-To delete your Agent Memory service:
+To delete your Redis Agent Memory service:
1. Select **Delete**.
@@ -111,11 +125,11 @@ To delete your Agent Memory service:
1. Select **Delete** again to confirm.
-Deleting the Agent Memory service is permanent and cannot be undone.
+Deleting the Redis Agent Memory service is permanent and cannot be undone.
## Metrics tab
-The **Metrics** tab provides a series of graphs showing performance data for your Agent Memory service.
+The **Metrics** tab provides a series of graphs showing performance data for your Redis Agent Memory service.
| Metric | Description |
|--------|-------------|
@@ -126,7 +140,7 @@ The **Metrics** tab provides a series of graphs showing performance data for you
The **API keys** tab shows a list of all API keys for your service.
-{{}}
+{{}}
Here, you can generate a new API key or remove any keys that are no longer in use. You can generate or remove service API keys at any time.
@@ -146,7 +160,7 @@ To generate a new service key:
1. The new key will appear in a dialog box. Select **Copy** to copy the key to the clipboard.
- {{}}
+ {{}}
{{}}
This is the only time the value of the user key is available. Save it to a secure location before closing the dialog box.
diff --git a/content/operate/rc/context-engine/context-retriever/_index.md b/content/operate/iris/context-retriever/_index.md
similarity index 95%
rename from content/operate/rc/context-engine/context-retriever/_index.md
rename to content/operate/iris/context-retriever/_index.md
index 065d3d7399..077c313134 100644
--- a/content/operate/rc/context-engine/context-retriever/_index.md
+++ b/content/operate/iris/context-retriever/_index.md
@@ -3,14 +3,16 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: Expose schema-first retrieval tools from your Redis Cloud data to AI agents.
hideListLinks: true
linktitle: Context Retriever
title: Redis Context Retriever on Redis Cloud
-weight: 37
+weight: 20
bannerText: Redis Context Retriever on Redis Cloud is currently available in preview. Features and behavior are subject to change.
bannerChildren: true
+aliases:
+- /operate/rc/context-engine/context-retriever/
---
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.
diff --git a/content/operate/rc/context-engine/context-retriever/create-service.md b/content/operate/iris/context-retriever/create-service.md
similarity index 95%
rename from content/operate/rc/context-engine/context-retriever/create-service.md
rename to content/operate/iris/context-retriever/create-service.md
index 6105d87062..f24556e0c6 100644
--- a/content/operate/rc/context-engine/context-retriever/create-service.md
+++ b/content/operate/iris/context-retriever/create-service.md
@@ -3,12 +3,14 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: Create a Context Retriever service in Redis Cloud to expose schema-first retrieval tools to AI agents.
hideListLinks: true
linktitle: Create service
title: Create a Context Retriever service
weight: 5
+aliases:
+- /operate/rc/context-engine/context-retriever/create-service/
---
Redis Context Retriever helps teams expose operational context to AI agents through schema-first retrieval. This guide walks you through creating and configuring a Context Retriever service in Redis Cloud.
@@ -18,7 +20,7 @@ Redis Context Retriever helps teams expose operational context to AI agents thro
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.
{{< note >}}
-Agent Memory does not support the following databases during public preview:
+Redis Context Retriever does not support the following databases during public preview:
- [Redis Flex]({{< relref "operate/rc/databases/create-database/create-flex-database">}}) databases
- [Active-Active]({{< relref "/operate/rc/databases/active-active" >}}) databases
{{< /note >}}
@@ -111,4 +113,4 @@ After you set all fields for all of your entities, select **Create** to create y
After your service is created, you can call the MCP tools Context Retriever exposes from your agent. See the [Context Surfaces Python Client](https://pypi.org/project/redis-context-retriever/) for more information on how to call your tools.
-You can also [view your service]({{< relref "/operate/rc/context-engine/context-retriever/view-service" >}}).
+You can also [view your service]({{< relref "/operate/iris/context-retriever/view-service" >}}).
diff --git a/content/operate/rc/context-engine/context-retriever/view-admin-keys.md b/content/operate/iris/context-retriever/view-admin-keys.md
similarity index 90%
rename from content/operate/rc/context-engine/context-retriever/view-admin-keys.md
rename to content/operate/iris/context-retriever/view-admin-keys.md
index 7b23bb08e5..6387bdee72 100644
--- a/content/operate/rc/context-engine/context-retriever/view-admin-keys.md
+++ b/content/operate/iris/context-retriever/view-admin-keys.md
@@ -3,15 +3,17 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: View and manage Context Retriever admin keys in Redis Cloud.
hideListLinks: true
linktitle: View admin keys
title: View and manage Context Retriever admin keys
weight: 25
+aliases:
+- /operate/rc/context-engine/context-retriever/view-admin-keys/
---
-After you have [created your first Context Retriever service]({{< relref "/operate/rc/context-engine/context-retriever/create-service" >}}), you can view and manage your admin keys from the **Admin keys** tab in the **Context Retriever** section of the Redis Cloud console.
+After you have [created your first Context Retriever service]({{< relref "/operate/iris/context-retriever/create-service" >}}), you can view and manage your admin keys from the **Admin keys** tab in the **Context Retriever** section of the Redis Cloud console.
A Context Retriever **admin key** authorizes administrative operations against Context Retriever in your Redis Cloud account, such as creating, updating, or deleting services and their entity models. You can use it with the [Context Surfaces Python Client](https://pypi.org/project/redis-context-retriever/) and `cxtctl` CLI to create an Agent key and call your tools.
diff --git a/content/operate/rc/context-engine/context-retriever/view-service.md b/content/operate/iris/context-retriever/view-service.md
similarity index 92%
rename from content/operate/rc/context-engine/context-retriever/view-service.md
rename to content/operate/iris/context-retriever/view-service.md
index 65622a3521..c4ff56371f 100644
--- a/content/operate/rc/context-engine/context-retriever/view-service.md
+++ b/content/operate/iris/context-retriever/view-service.md
@@ -3,15 +3,17 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: View and manage your Context Retriever service in Redis Cloud.
hideListLinks: true
linktitle: View service
title: View and manage Context Retriever service
weight: 15
+aliases:
+- /operate/rc/context-engine/context-retriever/view-service/
---
-After you have [created your first Context Retriever service]({{< relref "/operate/rc/context-engine/context-retriever/create-service" >}}), selecting **Context Retriever** from the Redis Cloud Console menu will take you to the **Context Retriever Services** page.
+After you have [created your first Context Retriever service]({{< relref "/operate/iris/context-retriever/create-service" >}}), selecting **Context Retriever** from the Redis Cloud Console menu will take you to the **Context Retriever Services** page.
This page displays a list of all Context Retriever services associated with your account.
@@ -75,4 +77,3 @@ To delete your Context Retriever service:
1. Select **Delete** again to confirm.
Deleting the Context Retriever service is permanent and cannot be undone.
-
diff --git a/content/operate/rc/context-engine/langcache/_index.md b/content/operate/iris/langcache/_index.md
similarity index 90%
rename from content/operate/rc/context-engine/langcache/_index.md
rename to content/operate/iris/langcache/_index.md
index 7888c298d6..b5d91310bd 100644
--- a/content/operate/rc/context-engine/langcache/_index.md
+++ b/content/operate/iris/langcache/_index.md
@@ -3,16 +3,17 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: Store LLM responses for AI applications in Redis Cloud.
hideListLinks: true
linktitle: LangCache
title: Semantic caching with LangCache on Redis Cloud
-weight: 36
+weight: 30
bannerText: LangCache on Redis Cloud is currently available as a public preview. Features and behavior are subject to change.
bannerChildren: true
aliases:
- /operate/rc/langcache
+- /operate/rc/context-engine/langcache/
---
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.
@@ -25,4 +26,4 @@ For more information about how LangCache works, see the [LangCache overview]({{<
## Get started with LangCache on Redis Cloud
-{{< embed-md "rc-langcache-get-started.md" >}}
\ No newline at end of file
+{{< embed-md "rc-langcache-get-started.md" >}}
diff --git a/content/operate/rc/context-engine/langcache/create-service.md b/content/operate/iris/langcache/create-service.md
similarity index 90%
rename from content/operate/rc/context-engine/langcache/create-service.md
rename to content/operate/iris/langcache/create-service.md
index cafa66d7bd..c7d4194a92 100644
--- a/content/operate/rc/context-engine/langcache/create-service.md
+++ b/content/operate/iris/langcache/create-service.md
@@ -3,7 +3,7 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: null
hideListLinks: true
linktitle: Create service
@@ -11,6 +11,7 @@ title: Create a LangCache service
weight: 5
aliases:
- /operate/rc/langcache/create-service
+- /operate/rc/context-engine/langcache/create-service/
---
Redis LangCache provides vector search capabilities and efficient caching for AI-powered applications. This guide walks you through creating and configuring a LangCache service in Redis Cloud.
@@ -51,12 +52,12 @@ From here:
{{}}
This is the only time the value of the user key is available. Save it to a secure location before closing the dialog box.
-If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
+If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/iris/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
{{}}
- After your cache is created, you can [use the LangCache API]({{< relref "/operate/rc/context-engine/langcache/use-langcache" >}}) from your client app.
+ After your cache is created, you can [use the LangCache API]({{< relref "/operate/iris/langcache/use-langcache" >}}) from your client app.
- You can also [view and edit the cache]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache" >}}) and [monitor the cache's performance]({{< relref "/operate/rc/context-engine/langcache/monitor-cache" >}}).
+ You can also [view and edit the cache]({{< relref "/operate/iris/langcache/view-edit-cache" >}}) and [monitor the cache's performance]({{< relref "/operate/iris/langcache/monitor-cache" >}}).
- If you want to customize your LangCache service, select **Create custom service**.
@@ -136,7 +137,7 @@ A window containing your LangCache service key will appear. Select **Copy** to c
{{}}
This is the only time the value of the user key is available. Save it to a secure location before closing the dialog box.
-If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
+If you lose the service key value, you will need to [generate a new service key]({{< relref "/operate/iris/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
{{}}
You'll be taken to your LangCache service's **Configuration** page. You'll also be able to see your LangCache service in the LangCache service list.
@@ -152,6 +153,6 @@ For help, [contact support](https://redis.io/support/).
## Next steps
-After your cache is created, you can [use the LangCache API]({{< relref "/operate/rc/context-engine/langcache/use-langcache" >}}) from your client app.
+After your cache is created, you can [use the LangCache API]({{< relref "/operate/iris/langcache/use-langcache" >}}) from your client app.
-You can also [view and edit the cache]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache" >}}) and [monitor the cache's performance]({{< relref "/operate/rc/context-engine/langcache/monitor-cache" >}}).
+You can also [view and edit the cache]({{< relref "/operate/iris/langcache/view-edit-cache" >}}) and [monitor the cache's performance]({{< relref "/operate/iris/langcache/monitor-cache" >}}).
diff --git a/content/operate/rc/context-engine/langcache/monitor-cache.md b/content/operate/iris/langcache/monitor-cache.md
similarity index 96%
rename from content/operate/rc/context-engine/langcache/monitor-cache.md
rename to content/operate/iris/langcache/monitor-cache.md
index 3f2ad3abad..17c79f2578 100644
--- a/content/operate/rc/context-engine/langcache/monitor-cache.md
+++ b/content/operate/iris/langcache/monitor-cache.md
@@ -3,7 +3,7 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: null
hideListLinks: true
linktitle: Monitor cache
@@ -11,6 +11,7 @@ title: Monitor a LangCache service
weight: 20
aliases:
- /operate/rc/langcache/monitor-cache
+- /operate/rc/context-engine/langcache/monitor-cache/
---
You can monitor a LangCache service's performance from the **Metrics** tab of the service's page.
@@ -50,4 +51,4 @@ High cache latency may indicate one of the following:
- Inefficient embedding generation from the embedding provider
- Large cache requiring longer comparison times
- Network latency between the cache and embedding provider
-- Resource constraints
\ No newline at end of file
+- Resource constraints
diff --git a/content/operate/rc/context-engine/langcache/use-langcache.md b/content/operate/iris/langcache/use-langcache.md
similarity index 77%
rename from content/operate/rc/context-engine/langcache/use-langcache.md
rename to content/operate/iris/langcache/use-langcache.md
index bbae49b6fd..f62e853f33 100644
--- a/content/operate/rc/context-engine/langcache/use-langcache.md
+++ b/content/operate/iris/langcache/use-langcache.md
@@ -3,7 +3,7 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: null
hideListLinks: true
linktitle: Use LangCache
@@ -11,6 +11,7 @@ title: Use the LangCache API on Redis Cloud
weight: 10
aliases:
- /operate/rc/langcache/use-langcache
+- /operate/rc/context-engine/langcache/use-langcache/
---
You can use the [LangCache API and SDK]({{< relref "/develop/ai/context-engine/langcache/api-examples" >}}) from your client app to store and retrieve LLM, RAG, or agent responses.
@@ -21,9 +22,9 @@ To access the LangCache API, you need:
- LangCache service API key
- Cache ID
-For LangCache on Redis Cloud, the base URL and cache ID are available in the LangCache service's **Configuration** page in the [**Connectivity** section]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache#connectivity" >}}).
+For LangCache on Redis Cloud, the base URL and cache ID are available in the LangCache service's **Configuration** page in the [**Connectivity** section]({{< relref "/operate/iris/langcache/view-edit-cache#connectivity" >}}).
-The LangCache API key is only available immediately after you create the LangCache service. If you lost this value, you will need to [replace the service API key]({{< relref "/operate/rc/context-engine/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
+The LangCache API key is only available immediately after you create the LangCache service. If you lost this value, you will need to [replace the service API key]({{< relref "/operate/iris/langcache/view-edit-cache#replace-service-api-key" >}}) to be able to use the LangCache API.
When you call the API, you need to pass the LangCache API key in the `Authorization` header as a Bearer token and the Cache ID as the `cacheId` path parameter.
diff --git a/content/operate/rc/context-engine/langcache/view-edit-cache.md b/content/operate/iris/langcache/view-edit-cache.md
similarity index 92%
rename from content/operate/rc/context-engine/langcache/view-edit-cache.md
rename to content/operate/iris/langcache/view-edit-cache.md
index 626b0e8d53..db3db6372a 100644
--- a/content/operate/rc/context-engine/langcache/view-edit-cache.md
+++ b/content/operate/iris/langcache/view-edit-cache.md
@@ -3,7 +3,7 @@ alwaysopen: false
categories:
- docs
- operate
-- rc
+- iris
description: null
hideListLinks: true
linktitle: View and edit cache
@@ -11,9 +11,10 @@ title: View and edit LangCache service
weight: 15
aliases:
- /operate/rc/langcache/view-edit-cache
+- /operate/rc/context-engine/langcache/view-edit-cache/
---
-After you have [created your first LangCache service]({{< relref "/operate/rc/context-engine/langcache/create-service" >}}), selecting **LangCache** from the Redis Cloud Console menu will take you to the **LangCache Services** page.
+After you have [created your first LangCache service]({{< relref "/operate/iris/langcache/create-service" >}}), selecting **LangCache** from the Redis Cloud Console menu will take you to the **LangCache Services** page.
This page displays a list of all LangCache services associated with your account.
@@ -43,7 +44,7 @@ The **Connectivity** section provides the connection details for your LangCache
Select the **Copy** button next to the Cache ID and API Base URL to copy them to the clipboard. If you lost the API key value or need to rotate the key, you can [generate a new service API key](#replace-service-api-key) at any time.
-See [use the LangCache API]({{< relref "/operate/rc/context-engine/langcache/use-langcache" >}}) for more information on how to use these values.
+See [use the LangCache API]({{< relref "/operate/iris/langcache/use-langcache" >}}) for more information on how to use these values.
#### Generate a new service API key {#replace-service-api-key}
@@ -129,4 +130,4 @@ Deleting the LangCache service is permanent and cannot be undone.
## Metrics tab
-The **Metrics** tab provides a series of graphs showing performance data for your LangCache service. See [Monitor a LangCache service]({{< relref "/operate/rc/context-engine/langcache/monitor-cache" >}}) for more information.
\ No newline at end of file
+The **Metrics** tab provides a series of graphs showing performance data for your LangCache service. See [Monitor a LangCache service]({{< relref "/operate/iris/langcache/monitor-cache" >}}) for more information.
diff --git a/content/operate/rc/changelog/july-2025.md b/content/operate/rc/changelog/july-2025.md
index ae68d183c1..282698336b 100644
--- a/content/operate/rc/changelog/july-2025.md
+++ b/content/operate/rc/changelog/july-2025.md
@@ -18,7 +18,7 @@ tags:
### LangCache public preview
-[LangCache]({{< relref "/operate/rc/context-engine/langcache" >}}) is now available in public preview on Redis Cloud.
+[LangCache]({{< relref "/operate/iris/langcache" >}}) is now available in public preview on Redis Cloud.
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.
diff --git a/content/operate/rc/changelog/may-2026.md b/content/operate/rc/changelog/may-2026.md
index 0a58f0b96f..dda94a09a6 100644
--- a/content/operate/rc/changelog/may-2026.md
+++ b/content/operate/rc/changelog/may-2026.md
@@ -18,7 +18,7 @@ tags:
### Redis Iris
-Redis Iris is a suite of fully-managed services that give AI agents the context engine they need to reliably act on business data. Both [Redis Agent Memory]({{< relref "/operate/rc/context-engine/agent-memory" >}}) and [Redis Context Retriever]({{< relref "/operate/rc/context-engine/context-retriever" >}}) are now available on Redis Cloud as a public preview.
+Redis Iris is a suite of fully-managed services that give AI agents the context engine they need to reliably act on business data. Both [Redis Agent Memory]({{< relref "/operate/iris/agent-memory" >}}) and [Redis Context Retriever]({{< relref "/operate/iris/context-retriever" >}}) are now available on Redis Cloud as a public preview.
### Bring your own Cloud resource tags
diff --git a/content/operate/rc/cloud-integrations/aws-marketplace/_index.md b/content/operate/rc/cloud-integrations/aws-marketplace/_index.md
index 74f50b18cd..01262ebed1 100644
--- a/content/operate/rc/cloud-integrations/aws-marketplace/_index.md
+++ b/content/operate/rc/cloud-integrations/aws-marketplace/_index.md
@@ -19,7 +19,7 @@ Here's how to subscribe to Redis Cloud with AWS Marketplace:
1. Sign in to the [AWS console](https://console.aws.amazon.com/).
-1. Search AWS Marketplace for [Redis Cloud: Real-Time Cache, Vector Search & AI Agent Memory](https://aws.amazon.com/marketplace/pp/prodview-mwscixe4ujhkq) and subscribe to the listing.
+1. Search AWS Marketplace for [Redis Cloud: Real-Time Data Layer for AI Apps & Agents](https://aws.amazon.com/marketplace/pp/prodview-mwscixe4ujhkq) and subscribe to the listing.
{{}}
diff --git a/content/operate/rc/context-engine/_index.md b/content/operate/rc/context-engine/_index.md
deleted file mode 100644
index a296d98031..0000000000
--- a/content/operate/rc/context-engine/_index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-alwaysopen: false
-categories:
-- docs
-- operate
-- rc
-description: Deploy AI agents with Redis Cloud.
-hideListLinks: false
-linktitle: Redis Iris context engine
-title: Redis Iris context engine on Redis Cloud
-weight: 36
----
\ No newline at end of file
diff --git a/content/operate/rc/context-engine/agent-memory/_index.md b/content/operate/rc/context-engine/agent-memory/_index.md
deleted file mode 100644
index 25a47cc2c3..0000000000
--- a/content/operate/rc/context-engine/agent-memory/_index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-alwaysopen: false
-categories:
-- docs
-- operate
-- rc
-description: Store agent memory for AI applications in Redis Cloud.
-hideListLinks: true
-linktitle: Agent Memory
-title: Redis Agent Memory on Redis Cloud
-weight: 36
-bannerText: Redis Agent Memory on Redis Cloud is currently available as a public preview. Features and behavior are subject to change.
-bannerChildren: true
----
-
-Redis Agent Memory is a memory service for AI Agents available as a REST API and Python SDK. It provides the persistent, structured memory layer that intelligent agents need to store, retrieve, and manage contextual data across interactions. Rather than requiring developers to build custom memory infrastructure from scratch, Redis Agent Memory offers a turnkey solution with dedicated endpoints, secure API key management, configurable memory schemas, and automatic TTL-based lifecycle management.
-
-## Redis Agent Memory overview
-
-Redis Agent Memory uses a two-tier memory model:
-
-- **Session memory** (also known as **short-term** or **working memory**) maintains the current conversation state, session history, and session-specific metadata. You can set a custom time-to-live (TTL) to control how long session data is retained.
-- **Long-term memory** stores information extracted from past sessions, such as user preferences and learned patterns, as text with vector embeddings for semantic retrieval.
-
-Promotion from short-term to long-term memory happens automatically. When you store a conversation event in session memory, the Agent Memory Server asynchronously extracts important information using the configured extraction strategy (discrete, summary, preferences, or custom) and stores it as long-term memory. The process is non-blocking, so agent interactions remain responsive. Short-term memory that is not promoted expires based on its TTL. You can also create long-term memories directly through the API for bulk creation or to import knowledge from external sources.
-
-For more details, see the [Redis Agent Memory overview]({{< relref "/develop/ai/context-engine/agent-memory" >}}).
-
-## Get started with Agent Memory on Redis Cloud
-
-{{< embed-md "rc-agent-memory-get-started.md" >}}
diff --git a/content/operate/rc/context-engine/agent-memory/use-agent-memory.md b/content/operate/rc/context-engine/agent-memory/use-agent-memory.md
deleted file mode 100644
index 2b8f0ccdf5..0000000000
--- a/content/operate/rc/context-engine/agent-memory/use-agent-memory.md
+++ /dev/null
@@ -1,182 +0,0 @@
----
-alwaysopen: false
-categories:
-- docs
-- operate
-- rc
-description: Create an Agent Memory service on Redis Cloud and make your first session-memory and long-term-memory REST API requests.
-hideListLinks: true
-linktitle: REST quickstart
-title: Redis Cloud Agent Memory REST quickstart
-weight: 10
----
-
-Use this quickstart to create an Agent Memory service on Redis Cloud and make your first REST API requests.
-
-{{< note >}}
-Redis Agent Memory on Redis Cloud is available as a public preview. Features and behavior can change before general availability.
-{{< /note >}}
-
-## Before you begin
-
-To complete this quickstart, you need:
-
-- A Redis Cloud account that can create Agent Memory services.
-- An eligible Redis Cloud database, or permission to create one.
-- A shell with `curl` installed.
-
-An eligible database is active, uses a Pro or Essentials plan, has a public endpoint and Query Engine, runs a supported Redis version, and has the default user enabled.
-
-Agent Memory doesn't support Flex, Active-Active, or AWS PrivateLink databases during public preview.
-
-For the complete list, see [prerequisites and limitations]({{< relref "/operate/rc/context-engine/agent-memory/create-service#prerequisites-and-limitations" >}}).
-
-## Create an Agent Memory service
-
-1. Sign in to the [Redis Cloud console](https://cloud.redis.io/).
-1. Select **Agent Memory** from the navigation menu.
-1. If Redis Cloud displays the public-preview terms, review and accept them.
-1. Select **Quick create** to use the default settings, or select **Create custom** and choose an eligible database.
-1. After Redis Cloud creates the service, copy the Agent Memory API key and store it securely.
-
-{{< warning >}}
-Redis Cloud displays the Agent Memory API key only once. If you lose it, [generate a new API key]({{< relref "/operate/rc/context-engine/agent-memory/view-service#replace-service-api-key" >}}).
-{{< /warning >}}
-
-For screenshots and configuration details, see [create an Agent Memory service]({{< relref "/operate/rc/context-engine/agent-memory/create-service" >}}).
-
-## Save the connection values
-
-1. Open the Agent Memory service in the Redis Cloud console.
-1. On the **Configuration** tab, copy the **API Base URL** and **Store ID**.
-1. Export the values in your shell. Replace each placeholder with the value from Redis Cloud:
-
- ```sh
- export AGENT_MEMORY_URL=''
- export STORE_ID=''
- export API_KEY=''
- export SESSION_ID='quickstart-session'
- export OWNER_ID='quickstart-user'
- export MEMORY_ID='quickstart-preference'
- ```
-
-Use the complete API base URL returned by Redis Cloud. Don't add another URL scheme, such as `https://`, to `AGENT_MEMORY_URL`.
-
-Send the API key as a bearer token in the `Authorization` header. Keep the key out of source control, application logs, and other unsecured locations.
-
-## Add a session event
-
-Set the event timestamp to the current Coordinated Universal Time (UTC):
-
-```sh
-export EVENT_CREATED_AT="$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
-```
-
-Add a user event to session memory:
-
-```sh
-curl --fail-with-body --silent --show-error \
- --request POST \
- --header "Authorization: Bearer $API_KEY" \
- --header 'Content-Type: application/json' \
- --data @- \
- "$AGENT_MEMORY_URL/v1/stores/$STORE_ID/session-memory/events" <}}).
-
-## Retrieve the session
-
-Retrieve the session event that you added:
-
-```sh
-curl --fail-with-body --silent --show-error \
- --header "Authorization: Bearer $API_KEY" \
- "$AGENT_MEMORY_URL/v1/stores/$STORE_ID/session-memory/$SESSION_ID"
-```
-
-A successful request returns `200 OK`. The response contains the session ID, owner ID, and stored events.
-
-For request and response details, see [`GetSessionMemory`]({{< relref "/develop/ai/context-engine/agent-memory/api-reference#tag/session-memory/operation/GetSessionMemory" >}}).
-
-## Understand automatic extraction
-
-Agent Memory processes session events asynchronously and extracts relevant information into long-term memory. By default, extraction runs on a five-minute cadence, so extracted memories might not appear immediately.
-
-The next step creates a long-term memory directly. This approach lets you verify long-term-memory search without waiting for automatic extraction.
-
-## Create a long-term memory
-
-Create a long-term memory for the same owner and session:
-
-```sh
-curl --fail-with-body --silent --show-error \
- --request POST \
- --header "Authorization: Bearer $API_KEY" \
- --header 'Content-Type: application/json' \
- --data @- \
- "$AGENT_MEMORY_URL/v1/stores/$STORE_ID/long-term-memory" <}}).
-
-## Search long-term memory
-
-Search for the long-term memory by meaning and owner:
-
-```sh
-curl --fail-with-body --silent --show-error \
- --request POST \
- --header "Authorization: Bearer $API_KEY" \
- --header 'Content-Type: application/json' \
- --data @- \
- "$AGENT_MEMORY_URL/v1/stores/$STORE_ID/long-term-memory/search" <}}).
-
-## Next steps
-
-- Review more [Agent Memory API examples]({{< relref "/develop/ai/context-engine/agent-memory/api-examples" >}}).
-- Use the [Agent Memory API reference]({{< relref "/develop/ai/context-engine/agent-memory/api-reference" >}}) for endpoint and schema details.
-- [View and manage the service]({{< relref "/operate/rc/context-engine/agent-memory/view-service" >}}) to update configuration, manage API keys, review metrics, flush memories, or delete the service.
diff --git a/layouts/operate/list.html b/layouts/operate/list.html
index adddd797a3..346043bd59 100644
--- a/layouts/operate/list.html
+++ b/layouts/operate/list.html
@@ -69,16 +69,10 @@
{{ else }}
- {{ $ancestorDirs := slice }}
- {{ with .File }}
- {{ $ancestorDirs = split .Dir "/" }}
- {{ end }}
- {{ $currPage := .Page }}
- {{ range $i, $page := $ancestorDirs }}
- {{ if and $currPage.Params.bannerText $currPage.Params.bannerChildren }}
- {{ partial "banner-article.html" $currPage }}
+ {{ range .Ancestors }}
+ {{ if and .Params.bannerText .Params.bannerChildren }}
+ {{ partial "banner-article.html" . }}
{{ end }}
- {{ $currPage = $currPage.Parent }}
{{ end }}
{{ end }}