diff --git a/HUGO_DEPENDENCY_ASSESSMENT.md b/HUGO_DEPENDENCY_ASSESSMENT.md
new file mode 100644
index 0000000000..9e6241ae99
--- /dev/null
+++ b/HUGO_DEPENDENCY_ASSESSMENT.md
@@ -0,0 +1,493 @@
+# Hugo dependency assessment
+
+Date assessed: 24 July 2026
+
+## Executive summary
+
+The documentation sources are heavily dependent on Hugo today, but most
+content-level lock-in is concentrated in a few conventions that can be
+replaced without changing the published experience.
+
+The highest-value changes are:
+
+1. Replace `relref` calls with ordinary Markdown links and resolve or validate
+   them with a link render hook.
+2. Replace note, warning, tip, and alert shortcodes with Markdown blockquote
+   alerts and a blockquote render hook.
+3. Replace the image shortcode with Markdown images and an image render hook.
+4. Replace code-related shortcodes with fenced code blocks.
+5. Use table render hooks for responsive Markdown tables.
+
+These changes would move Hugo-specific behavior out of thousands of content
+files and into a small rendering adapter. The equivalent adapter could later
+be implemented for another site generator.
+
+Some shortcodes are not merely presentational. Features such as generated
+multi-client examples, content transclusion, child-page tables, and
+data-driven command lists require preprocessing or an equivalent data and
+page-model API. Render hooks are not an appropriate replacement for these.
+
+## Scope and methodology
+
+This assessment covers the current repository checkout and:
+
+- 5,146 Markdown files under `content/`
+- Hugo v0.143.1
+- 41 shortcode templates
+- 6 existing render hooks
+- 153 layout files
+
+Shortcode calls and affected files were counted across the Markdown sources.
+Front matter, content organization, raw HTML, Hugo configuration, layout
+templates, data access, alternate output formats, and build scripts were also
+reviewed.
+
+## Content-level dependency inventory
+
+| Construct | Instances | Files affected | Assessment |
+|---|---:|---:|---|
+| `relref` | 26,856 | 3,524 | Largest dependency; readily replaceable |
+| Note, warning, tip, info, and alert shortcodes | 2,960 | 1,290 | Readily replaceable with blockquote alerts |
+| `image` | 1,648 | 445 | Mostly replaceable with Markdown images |
+| `highlight`, `code`, and `redis-cli` | 749 | 340 | Mostly replaceable with fenced code blocks |
+| `multitabs` | 624 | 585 | Needs a different progressive-enhancement design |
+| `clients-example` | 564 | 109 | Data-generation feature |
+| `embed-md` | 299 | 207 | Content transclusion; no standard Markdown equivalent |
+| `embed-yaml` | 136 | 32 | Better handled by preprocessing |
+| `table-children` | 94 | 89 | Depends on Hugo's page tree |
+| Other specialized shortcodes | 409 | — | Mixed presentation and data-generation features |
+
+Overall:
+
+- 3,932 files, approximately 76%, contain at least one shortcode, including
+  `relref`.
+- 2,297 files, approximately 45%, contain at least one custom, non-built-in
+  shortcode.
+- Replacing links, callouts, images, and code wrappers would remove about 94%
+  of all shortcode invocations.
+- After those migrations, approximately 1,098 files and 2,126 genuinely custom
+  shortcode calls would remain.
+
+## Recommended source conventions
+
+| Current convention | Preferred source form | Hugo implementation |
+|---|---|---|
+| `[text]({{< relref "…" >}})` | Ordinary Markdown link | Link render hook resolves and validates it |
+| `{{< image … >}}` | `![alt](image-path)` | Image render hook adds lightbox and link behavior |
+| `note`, `warning`, `tip`, `info`, `alert` | `> [!NOTE]`, `> [!WARNING]`, etc. | Blockquote render hook produces the existing alert markup |
+| `highlight`, `code` | Fenced code block | Default renderer or code-block hook |
+| `redis-cli` | A `redis-cli` fenced code block | Code-block hook adds terminal presentation |
+| `table-scrollable` | Ordinary Markdown table | Table render hook adds a responsive wrapper |
+| `definition` | Markdown definition list | Goldmark definition-list support |
+| Diagrams and interactive checklists | Existing typed code fences | Retain the current render-hook pattern |
+
+Hugo supports render hooks for links, images, blockquotes, code blocks,
+headings, passthrough elements, and tables. These hooks are well suited to
+presentation changes applied to otherwise meaningful Markdown.
+
+See the [Hugo render-hook documentation](https://gohugo.io/render-hooks/introduction/).
+
+## Links
+
+Use ordinary source-relative Markdown links as the canonical form:
+
+```markdown
+[Transactions](../using-commands/transactions.md)
+```
+
+A Hugo link render hook can:
+
+- resolve the source file to its published permalink;
+- retain the current base-URL behavior;
+- distinguish internal, external, and fragment-only links;
+- report unresolved pages during the build.
+
+An independent Markdown link checker should also run in CI so that link
+correctness does not itself depend on Hugo.
+
+Source-relative links are preferable to versioned site URLs because they work
+in repository viewers and generic Markdown tooling without coupling the
+source to a particular deployment prefix.
+
+### Prototype findings
+
+A link render hook was prototyped and tested (DOC-6909). It is committed at
+[`layouts/_default/_markup/render-link.html`](layouts/_default/_markup/render-link.html).
+The method: add the hook, convert every `relref` in `content/develop/clients/`
+(1,072 calls across 110 files) to plain Markdown links, build, and diff
+rendered link targets against a `relref` baseline.
+
+**Parity is exact.** Across 125 client pages, every internal link resolved
+byte-for-byte identically to `relref`, including anchors, mixed-case paths,
+bare page-relative paths, and `.md` suffixes. The only remaining differences
+were cosmetic percent-encoding of literal parentheses in external URLs
+(`(` becomes `%28`), which Goldmark applies to the destination it hands the
+hook.
+
+**`relref` and plain links can coexist.** They do not have to be migrated in a
+single pass. When a `relref` is still present its destination is Hugo's internal
+shortcode placeholder at hook time; the shortcode expands afterwards and
+substitutes the real URL back in — even inside the `href` the hook emitted. The
+hook therefore includes a transition guard: if the destination still contains a
+shortcode placeholder, it is passed through untouched and no warning is emitted.
+Without that guard, an in-progress migration logs one spurious "unresolved"
+warning per un-migrated `relref` (26,847 in this repository), which would bury
+the genuine broken-link warnings. Remove the guard once every `relref` has been
+migrated.
+
+**Internal links are not only content pages.** The use-case demos link to
+companion source files that ship in the page bundle, e.g. `[source](cache.rs)`.
+These are page resources, not pages, so `GetPage` cannot see them; the hook
+resolves them with `.Page.Resources.GetMatch` before reporting a link as
+unresolved. With that in place the remaining build warnings are mostly genuine
+signal — real dead links, alias/redirect targets that `GetPage` cannot resolve,
+and static-directory files.
+
+**Installing the hook is the atomic event, not the content migration.** The
+hook is global, so on the day it lands it reprocesses every plain Markdown link
+that already exists in the repository — for example the reply-type links in the
+command reference pages, which are authored as `../../develop/...` relative
+links, not `relref`. For those pre-existing links the hook applies harmless
+normalisation (relative to absolute, `.md` stripped, trailing slash added); the
+targets are unchanged. Content conversion can then proceed gradually, but the
+hook itself must be parity-tested against the whole site, not only against the
+pages being migrated.
+
+**A hook must be as robust as Hugo's built-in renderer.** Testing surfaced four
+defects that only appear at corpus scale, each of which silently dropped pages
+or failed the build:
+
+1. `.Page.File.Path` panics with a nil-pointer dereference on pages that have no
+   backing file — content generated via `markdownify` (the command pages) and
+   shortcode inner content (`note`, `alert`). Use `.Page.Path` instead.
+2. `urls.Parse` hard-errors on a malformed destination (a pre-existing
+   `[Authority]([Authority](https://...))` link) and fails the entire build.
+   Detect external links with a `findRE` scheme match instead.
+3. The unresolved-link fallback duplicated the fragment (`#cas#cas`) because it
+   re-appended an anchor that the destination already contained.
+4. `GetPage` cannot resolve alias (redirect-stub) targets, so links to aliased
+   paths produce false "unresolved" warnings even though the output is correct.
+
+Before a migration, run the hook site-wide and fix pre-existing malformed links,
+which a hook converts from silently-wrong output into hard build failures.
+
+### Scaling across diverse sections
+
+To check that parity was not specific to one section, the conversion was
+repeated across four structurally different areas at once — 825 files and about
+5,000 `relref` calls — each chosen to exercise a distinct feature:
+
+| Section | Feature exercised |
+|---|---|
+| `operate/rs/databases/active-active` | Content mounted under two URL paths |
+| `operate/rc` | Image-heavy pages; the target of that mount |
+| `operate/kubernetes` | Mixed-case paths and generated API-reference pages |
+| `integrate` | Cross-tree links |
+
+The build produced no errors, dropped no pages, and added no new warnings.
+Every rendered-link difference against the `relref` baseline was benign
+normalisation (relative to absolute, `.md` stripped, trailing slash added).
+
+The mounted Active-Active tree is the most demanding case, because the same
+source file is published under both `/operate/rs/…` and `/operate/rc/…`. The
+hook resolves each relative link to the mount-appropriate permalink — for
+example `develop/data-types` renders as
+`/operate/rs/databases/active-active/develop/data-types/` under the Software
+path and `/operate/rc/databases/active-active/develop/data-types/` under the
+Cloud path — matching `relref` exactly on both. This relies on resolving with
+`.PageInner`.
+
+A versioned tree (`operate/rs/7.8`, 326 files) was converted separately. All
+435 of its pages carry a `url:` front-matter override, and `GetPage`'s
+`.RelPermalink` honours those overrides identically to `relref`: parity was
+exact apart from the cosmetic external-parenthesis encoding. This pass also
+surfaced and fixed the last render-hook edge case — a malformed link whose
+anchor contained an embedded URL with its own `#`. Composing the resolved href
+without `safeURL` made Go's template autoescaper blank it to `ZgotmplZ`, and
+splitting the anchor on every `#` truncated it. The hook now applies `safeURL`
+to the composed URL and splits on the first `#` only, so such anchors are
+preserved intact and match the baseline.
+
+Version-specific links also interact with the archiving tool described below.
+
+### Tooling that assumes `relref`
+
+Several build and authoring tools treat `relref` as a literal string — they
+parse or generate the shortcode directly. These must be updated or retired as
+part of the migration, or they will silently produce wrong output:
+
+- [`build/version_archiver.py`](build/version_archiver.py) rewrites
+  `{{< relref "/…" >}}` with a regular expression to make links version-specific
+  when a versioned documentation snapshot is created. Against plain Markdown
+  links it matches nothing, so archived versions would keep unversioned links.
+- [`build/redisvl_docs_sync.py`](build/redisvl_docs_sync.py) is an importer that
+  *emits* `relref` syntax when converting upstream RedisVL documentation. It
+  would need to emit plain Markdown links instead.
+- [`.claude/hooks/check_shortcode_paths.py`](.claude/hooks/check_shortcode_paths.py)
+  validates `relref` target paths on edit. Once links are plain Markdown, that
+  validation moves to the render hook and an independent link checker.
+- [`layouts/partials/process-markdown-content.html`](layouts/partials/process-markdown-content.html)
+  regex-replaces `relref` when generating the Markdown and JSON outputs (see
+  "Current alternate-output fragility" below); standard links would let the
+  render hook handle this instead.
+
+An audit for `relref` used as a literal string across `build/`, `layouts/`, and
+`.claude/` should be part of migration planning.
+
+## Callouts
+
+Replace callout shortcodes with GitHub-style blockquote alerts:
+
+```markdown
+> [!WARNING]
+> Back up the database before continuing.
+```
+
+Hugo v0.143.1 supports the necessary blockquote render hooks and alert
+metadata. Unsupported Markdown processors still display the content as a
+normal blockquote.
+
+A blockquote render hook is prototyped at
+[`layouts/_default/_markup/render-blockquote.html`](layouts/_default/_markup/render-blockquote.html).
+It renders `> [!NOTE]` / `> [!WARNING]` / `> [!TIP]` / `> [!INFO]` and similar
+alerts with the same styling as the current note/warning/tip/info/alert
+shortcodes, and leaves regular blockquotes rendering exactly as before
+(verified byte-identical). Crucially, an alert body is native Markdown, so its
+links are rendered in the page's context and resolve correctly — unlike the
+shortcodes, which `markdownify` their inner content in a page-less context and
+so break relative links. **This makes the blockquote migration a prerequisite
+for portable, source-relative links inside callouts**, not merely a cosmetic
+change.
+
+Migration should use a Markdown- or shortcode-aware parser rather than regular
+expressions. At least 544 existing callouts contain nested shortcodes, and
+some callout bodies are very large. Inner shortcodes should be migrated before
+their enclosing callout where possible.
+
+## Images
+
+Approximately 1,093 of the 1,648 image calls use only a filename and optional
+alt text. These can be converted directly:
+
+```markdown
+![Database update status](/images/rc/status.png)
+```
+
+An image render hook can retain:
+
+- the link to the full image;
+- lightbox behavior;
+- URL normalization;
+- the existing `#no-click` convention, if it is still required;
+- optional titles and semantic styling.
+
+The remaining image calls use `width` or `class`. The preferred options are:
+
+1. Remove unnecessary per-image sizing through responsive CSS.
+2. Replace arbitrary classes with a small set of semantic styles such as
+   `inline-icon`, `small`, or `wide`.
+3. Use Goldmark image attributes only for genuine exceptions.
+
+Goldmark attributes are not CommonMark, but they degrade more gracefully than
+Hugo shortcode calls. Arbitrary Tailwind class strings should not form part of
+the long-term content schema.
+
+There is also an accessibility opportunity: 418 image shortcode calls do not
+currently specify alt text.
+
+The current image shortcode declares a default width of 75%, but does not
+apply it. Only explicitly provided widths appear in the rendered `img`
+element. See [`layouts/shortcodes/image.html`](layouts/shortcodes/image.html).
+
+## Code blocks and tables
+
+Replace `highlight` and `code` shortcodes with normal fenced code blocks.
+Replace `redis-cli` with a `redis-cli` fenced block and use a code-block render
+hook to add the current terminal chrome.
+
+A table render hook can wrap ordinary Markdown tables in a responsive
+overflow container. This removes the need for the `table-scrollable`
+shortcode without sacrificing the current HTML behavior.
+
+The repository already follows this progressive-enhancement approach for
+Mermaid diagrams, checklists, hierarchies, decision trees, and timelines. See
+[`for-ais-only/render_hook_docs/README.md`](for-ais-only/render_hook_docs/README.md).
+
+## Tabs
+
+There is no standard Markdown representation for tabs. The best portable
+source is ordinary titled sections:
+
+```markdown
+### RESP2
+
+RESP2 return information.
+
+### RESP3
+
+RESP3 return information.
+```
+
+JavaScript can progressively enhance recognized groups into tabs. Other
+renderers will show the sections sequentially, which is a useful and
+accessible fallback.
+
+Of the 624 `multitabs` calls, 534 are in command-reference pages. Their
+generator should emit RESP headings directly instead of emitting shortcode
+syntax. Arbitrary tab sets could use a generator-neutral marker, but such a
+marker would still be a custom extension rather than standard Markdown.
+
+## Dependencies that render hooks should not replace
+
+The following features generate or transclude content rather than simply
+altering Markdown presentation:
+
+- `clients-example` joins generated example data, client configuration,
+  source files, and command metadata.
+- `jupyter-example` reads source content and configures interactive notebook
+  behavior.
+- `embed-md` transcludes another page through Hugo's page API.
+- `embed-yaml`, `embed-code`, and `code-include` read files during rendering.
+- `table-children` queries Hugo's page tree and child-page front matter.
+- `command-group` generates command lists from data files.
+- `rc-supported-regions`, `table-csv`, `external-json`, and similar
+  shortcodes generate content from local or remote data.
+
+These should be moved to a generator-neutral preprocessing stage:
+
+```text
+authored Markdown + manifests + shared fragments
+                 |
+                 v
+       repository build tools
+                 |
+                 v
+      fully expanded Markdown tree
+                 |
+                 v
+      Hugo or another site generator
+```
+
+The expanded Markdown tree becomes a portable intermediate representation.
+Hugo and any future generator can consume the same tree. The authoring layer
+may retain a small project-specific directive or manifest schema, but it no
+longer depends on Go templates or Hugo's page APIs.
+
+## Page-model and build dependencies
+
+Removing shortcodes would not by itself make the complete site
+generator-independent. The repository also relies on:
+
+- 992 `_index.md` files for section pages and hierarchy;
+- front matter fields such as `weight`, `alwaysopen`, `hideListLinks`, `url`,
+  `aliases`, `type`, `layout`, and `cascade`;
+- 701 alias declarations;
+- page-tree navigation and sorting;
+- Hugo's data directory and site configuration;
+- Hugo's asset pipeline;
+- related-content, taxonomy, menu, and template APIs;
+- alternate Markdown and JSON output formats;
+- a Hugo module mount that exposes the same Active-Active source under both
+  Redis Software and Redis Cloud paths.
+
+YAML front matter is broadly supported by documentation generators, but the
+project should define its own metadata schema. Generator adapters can then map
+that schema to Hugo or a future system.
+
+The content mount is configured in [`config.toml`](config.toml). A portable
+replacement would materialize the duplicated tree during preprocessing or
+model the shared content explicitly in a manifest.
+
+## Raw HTML
+
+An approximate scan found recognized raw HTML elements outside code fences in
+1,819 Markdown files. Much of the volume is generated table and REST API
+markup, including:
+
+- tables and table cells;
+- `details` and `summary`;
+- `span`, `br`, and `nobr`;
+- raw links and images;
+- formatting elements.
+
+Raw HTML is not Hugo-specific, and many Markdown systems support it, but its
+security policy and styling vary between renderers. The current repository
+explicitly enables unsafe Goldmark rendering in [`config.toml`](config.toml).
+
+Raw HTML should therefore be treated as a secondary portability workstream.
+Generated tables, `<br>`, `<span>`, `<nobr>`, and manually constructed
+`<details>` blocks are the best initial targets.
+
+## Current alternate-output fragility
+
+The Markdown and JSON output pipeline already has to recreate Hugo shortcode
+behavior through regular-expression replacements. It explicitly handles a
+subset of constructs, repeatedly unescapes HTML entities, and finally removes
+all remaining shortcode tags.
+
+See
+[`layouts/partials/process-markdown-content.html`](layouts/partials/process-markdown-content.html).
+
+This is evidence of the maintenance cost of storing presentation macros in the
+source. Standardizing source Markdown would simplify HTML rendering, AI-facing
+Markdown, JSON generation, indexing, and future migrations at the same time.
+
+## Recommended migration sequence
+
+### Phase 1: establish conventions and adapters
+
+1. Define canonical conventions for links, images, callouts, code blocks, and
+   tables.
+2. Add link, image, blockquote, and table render hooks.
+3. Add generator-independent link and content linting to CI.
+4. Prevent new uses of replaceable shortcodes.
+
+### Phase 2: remove high-volume presentation shortcodes
+
+1. Migrate `relref` calls to normal Markdown links.
+2. Migrate callouts after converting their nested shortcodes.
+3. Convert simple image calls and address missing alt text.
+4. Convert code wrappers to fenced code blocks.
+5. Remove `table-scrollable` through the table hook.
+6. Update importers and generators so they emit the new conventions.
+
+### Phase 3: improve progressive enhancement
+
+1. Change generated RESP tabs to ordinary headings.
+2. Progressively enhance appropriate heading groups into tabs.
+3. Replace small presentational shortcodes with semantic Markdown or HTML.
+4. Continue using typed code fences for diagrams and structured interactive
+   content.
+
+### Phase 4: isolate true generation features
+
+1. Define a generator-neutral schema for includes and data-driven components.
+2. Expand those components into a portable Markdown build tree before Hugo
+   runs.
+3. Move mounted or duplicated content into the same preprocessing layer.
+4. Define and document the portable front matter schema.
+
+### Phase 5: prove portability
+
+1. Feed the expanded Markdown tree to a second renderer in CI.
+2. Compare page counts, resolved links, headings, metadata, and essential
+   semantic content.
+3. Treat visual parity as an adapter concern rather than an authoring-format
+   concern.
+
+## Conclusion
+
+The repository is strongly tied to Hugo as a complete publishing system, but
+the authoring format can be made substantially more portable without replacing
+Hugo.
+
+The immediate goal should be:
+
+> Store semantic, readable Markdown in `content/`, and use Hugo only as a
+> rendering and publishing adapter.
+
+Render hooks provide a practical route for links, images, callouts, code
+blocks, tables, and structured fenced blocks. True content-generation
+features should be isolated behind a preprocessing boundary. Together, these
+changes would reduce the cost and risk of evaluating another documentation
+platform while preserving the existing Hugo site.
diff --git a/content/commands/discard.md b/content/commands/discard.md
index 2953b9bf4f..708aec98ef 100644
--- a/content/commands/discard.md
+++ b/content/commands/discard.md
@@ -33,7 +33,7 @@ title: DISCARD
 Flushes all previously queued commands in a [transaction][tt] and restores the
 connection state to normal.
 
-[tt]: /develop/interact/transactions
+[tt]: /develop/using-commands/transactions
 
 If [`WATCH`]({{< relref "/commands/watch" >}}) was used, `DISCARD` unwatches all keys watched by the connection.
 
diff --git a/content/commands/exec.md b/content/commands/exec.md
index f94d138d82..977d9bc5b1 100644
--- a/content/commands/exec.md
+++ b/content/commands/exec.md
@@ -37,12 +37,12 @@ This command's behavior varies in clustered Redis environments. See the [multi-k
 Executes all previously queued commands in a [transaction][tt] and restores the
 connection state to normal.
 
-[tt]: /develop/interact/transactions
+[tt]: /develop/using-commands/transactions
 
 When using [`WATCH`]({{< relref "/commands/watch" >}}), `EXEC` will execute commands only if the watched keys were
 not modified, allowing for a [check-and-set mechanism][ttc].
 
-[ttc]: /develop/interact/transactions#cas
+[ttc]: /develop/using-commands/transactions#cas
 
 ## Redis Software and Redis Cloud compatibility
 
diff --git a/content/commands/expire.md b/content/commands/expire.md
index 3140fd4839..86ce2582fc 100644
--- a/content/commands/expire.md
+++ b/content/commands/expire.md
@@ -104,7 +104,7 @@ Note that calling `EXPIRE`/[`PEXPIRE`]({{< relref "/commands/pexpire" >}}) with
 will be `del`, not `expired`).
 
 [del]: /commands/del
-[ntf]: /develop/use/keyspace-notifications
+[ntf]: /develop/pubsub/keyspace-notifications
 
 ## Required arguments
 
diff --git a/content/commands/multi.md b/content/commands/multi.md
index 594efced49..1b92600ded 100644
--- a/content/commands/multi.md
+++ b/content/commands/multi.md
@@ -38,7 +38,7 @@ This command's behavior varies in clustered Redis environments. See the [multi-k
 Marks the start of a [transaction][tt] block.
 Subsequent commands will be queued for atomic execution using [`EXEC`]({{< relref "/commands/exec" >}}).
 
-[tt]: /develop/interact/transactions
+[tt]: /develop/using-commands/transactions
 
 ## Redis Software and Redis Cloud compatibility
 
diff --git a/content/commands/setbit.md b/content/commands/setbit.md
index f5df4b74c1..8a380bcc5c 100644
--- a/content/commands/setbit.md
+++ b/content/commands/setbit.md
@@ -147,7 +147,7 @@ native programming language. Symmetrically, it is also possible to set an entire
 bitmap by performing the bits-to-bytes encoding in the client and calling [`SET`]({{< relref "/commands/set" >}})
 with the resultant string.
 
-[ti]: /develop/data-types-intro#bitmaps
+[ti]: /develop/data-types#bitmaps
 
 ### Pattern: setting multiple bits
 
diff --git a/content/commands/unwatch.md b/content/commands/unwatch.md
index d00ca91544..0b03cd8e32 100644
--- a/content/commands/unwatch.md
+++ b/content/commands/unwatch.md
@@ -32,7 +32,7 @@ title: UNWATCH
 ---
 Flushes all the previously watched keys for a [transaction][tt].
 
-[tt]: /develop/interact/transactions
+[tt]: /develop/using-commands/transactions
 
 If you call [`EXEC`]({{< relref "/commands/exec" >}}) or [`DISCARD`]({{< relref "/commands/discard" >}}), there's no need to manually call `UNWATCH`.
 
diff --git a/content/commands/watch.md b/content/commands/watch.md
index 59baa395d2..3c6eb6949b 100644
--- a/content/commands/watch.md
+++ b/content/commands/watch.md
@@ -56,7 +56,7 @@ This command's behavior varies in clustered Redis environments. See the [multi-k
 Marks the given keys to be watched for conditional execution of a
 [transaction][tt].
 
-[tt]: /develop/interact/transactions
+[tt]: /develop/using-commands/transactions
 
 ## Redis Software and Redis Cloud compatibility
 
diff --git a/content/develop/ai/redisvl/0.14.0/user_guide/sql_to_redis_queries.md b/content/develop/ai/redisvl/0.14.0/user_guide/sql_to_redis_queries.md
index daadf91012..735e8ce8c2 100644
--- a/content/develop/ai/redisvl/0.14.0/user_guide/sql_to_redis_queries.md
+++ b/content/develop/ai/redisvl/0.14.0/user_guide/sql_to_redis_queries.md
@@ -500,7 +500,7 @@ results
 
 ### Aggregations
 
-See docs for redis supported reducer functions: [https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations/#supported-groupby-reducers](docs).
+See docs for redis supported reducer functions: [docs](https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/aggregations/#supported-groupby-reducers).
 
 
 ```python
diff --git a/content/develop/ai/redisvl/0.23.0/user_guide/how_to_guides/mcp_authentication.md b/content/develop/ai/redisvl/0.23.0/user_guide/how_to_guides/mcp_authentication.md
index f8bd258f36..5415241485 100644
--- a/content/develop/ai/redisvl/0.23.0/user_guide/how_to_guides/mcp_authentication.md
+++ b/content/develop/ai/redisvl/0.23.0/user_guide/how_to_guides/mcp_authentication.md
@@ -19,7 +19,7 @@ authenticated.
 Authentication is a separate concern from **transport security** (Host/Origin
 validation), which is always on for the HTTP transports and defends against DNS
 rebinding independently of auth. See
-[Transport Security](mcp.md#transport-security-host-origin-validation). Both
+[Transport Security]({{< relref "mcp#transport-security-host-origin-validation" >}}). Both
 layers apply together: auth decides *who* may call; the Host/Origin guard
 rejects requests whose claimed authority is not allowlisted.
 {{< /note >}}
diff --git a/content/develop/ai/redisvl/0.6.0/user_guide/_index.md b/content/develop/ai/redisvl/0.6.0/user_guide/_index.md
index f6e957b3bc..d3d3f5cbd9 100644
--- a/content/develop/ai/redisvl/0.6.0/user_guide/_index.md
+++ b/content/develop/ai/redisvl/0.6.0/user_guide/_index.md
@@ -84,13 +84,3 @@ User guides provide helpful resources for using RedisVL and its different compon
   * [Optimize](threshold_optimization/#optimize)
   * [Test it out](threshold_optimization/#test-it-out)
   * [Cleanup](threshold_optimization/#cleanup)
-* [Release Guides](release_guide/)
-  * [0.5.1 Feature Overview](release_guide/0_5_0_release/)
-  * [HybridQuery class](release_guide/0_5_0_release/#hybridquery-class)
-  * [TextQueries](release_guide/0_5_0_release/#textqueries)
-  * [Threshold optimization](release_guide/0_5_0_release/#threshold-optimization)
-  * [Schema validation](release_guide/0_5_0_release/#schema-validation)
-  * [Timestamp filters](release_guide/0_5_0_release/#timestamp-filters)
-  * [Batch search](release_guide/0_5_0_release/#batch-search)
-  * [Vector normalization](release_guide/0_5_0_release/#vector-normalization)
-  * [Hybrid policy on knn with filters](release_guide/0_5_0_release/#hybrid-policy-on-knn-with-filters)
diff --git a/content/develop/ai/redisvl/0.7.0/user_guide/_index.md b/content/develop/ai/redisvl/0.7.0/user_guide/_index.md
index 6376349e2f..6f878b0f19 100644
--- a/content/develop/ai/redisvl/0.7.0/user_guide/_index.md
+++ b/content/develop/ai/redisvl/0.7.0/user_guide/_index.md
@@ -84,13 +84,3 @@ User guides provide helpful resources for using RedisVL and its different compon
   * [Optimize](threshold_optimization/#optimize)
   * [Test it out](threshold_optimization/#test-it-out)
   * [Cleanup](threshold_optimization/#cleanup)
-* [Release Guides](release_guide/)
-  * [0.5.1 Feature Overview](release_guide/0_5_0_release/)
-  * [HybridQuery class](release_guide/0_5_0_release/#hybridquery-class)
-  * [TextQueries](release_guide/0_5_0_release/#textqueries)
-  * [Threshold optimization](release_guide/0_5_0_release/#threshold-optimization)
-  * [Schema validation](release_guide/0_5_0_release/#schema-validation)
-  * [Timestamp filters](release_guide/0_5_0_release/#timestamp-filters)
-  * [Batch search](release_guide/0_5_0_release/#batch-search)
-  * [Vector normalization](release_guide/0_5_0_release/#vector-normalization)
-  * [Hybrid policy on knn with filters](release_guide/0_5_0_release/#hybrid-policy-on-knn-with-filters)
diff --git a/content/develop/ai/redisvl/user_guide/how_to_guides/mcp_authentication.md b/content/develop/ai/redisvl/user_guide/how_to_guides/mcp_authentication.md
index 364d366a20..7b9e11f067 100644
--- a/content/develop/ai/redisvl/user_guide/how_to_guides/mcp_authentication.md
+++ b/content/develop/ai/redisvl/user_guide/how_to_guides/mcp_authentication.md
@@ -20,7 +20,7 @@ authenticated.
 Authentication is a separate concern from **transport security** (Host/Origin
 validation), which is always on for the HTTP transports and defends against DNS
 rebinding independently of auth. See
-[Transport Security](mcp.md#transport-security-host-origin-validation). Both
+[Transport Security]({{< relref "mcp#transport-security-host-origin-validation" >}}). Both
 layers apply together: auth decides *who* may call; the Host/Origin guard
 rejects requests whose claimed authority is not allowlisted.
 {{< /note >}}
diff --git a/content/develop/ai/search-and-query/advanced-concepts/aggregations-syntax.md b/content/develop/ai/search-and-query/advanced-concepts/aggregations-syntax.md
index 17ed7fc3a7..30bb605d4f 100644
--- a/content/develop/ai/search-and-query/advanced-concepts/aggregations-syntax.md
+++ b/content/develop/ai/search-and-query/advanced-concepts/aggregations-syntax.md
@@ -23,10 +23,6 @@ The [main aggregations page]({{< relref "/develop/ai/search-and-query/advanced-c
 
 `GROUPBY` ... `REDUCE` ... `APPLY` ... `GROUPBY` ... `REDUCE`
 
-{{< note >}}
-The examples on this page are based on a hypothetical "products" data set, which you can [download here](./data/products.txt).
-{{< /note >}}
-
 ## Syntax and expression ordering
 
 The `FT.AGGREGATE` command processes multiple expressions in a pipeline. Below is the recommended order:
diff --git a/content/develop/clients/nodejs/amr.md b/content/develop/clients/nodejs/amr.md
index 7384f0f4ef..edc0f976a1 100644
--- a/content/develop/clients/nodejs/amr.md
+++ b/content/develop/clients/nodejs/amr.md
@@ -155,7 +155,7 @@ authorityConfig: {
   },
 // ...
 ```
-See Microsoft's [Authority]([Authority](https://learn.microsoft.com/en-us/entra/identity-platform/msal-client-application-configuration#authority))
+See Microsoft's [Authority](https://learn.microsoft.com/en-us/entra/identity-platform/msal-client-application-configuration#authority)
 docs for more information.
 
 ### Authenticate with a service principal
diff --git a/content/develop/clients/redis-py/_index.md b/content/develop/clients/redis-py/_index.md
index 6ed1ed4195..b1d551888b 100644
--- a/content/develop/clients/redis-py/_index.md
+++ b/content/develop/clients/redis-py/_index.md
@@ -26,10 +26,10 @@ weight: 1
 The sections below explain how to install `redis-py` and connect your application
 to a Redis database.
 
-`redis-py` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+`redis-py` requires a running Redis server. See [here](../../../operate/oss_and_stack/install/_index.md) for Redis Open Source installation instructions.
 
 You can also access Redis with an object-mapping client interface. See
-[RedisOM for Python]({{< relref "/integrate/redisom-for-python" >}})
+[RedisOM for Python](../../../integrate/redisom-for-python/_index.md)
 for more information.
 
 ## Install
diff --git a/content/develop/clients/redis-py/amr.md b/content/develop/clients/redis-py/amr.md
index 9ce009116d..dc89bda336 100644
--- a/content/develop/clients/redis-py/amr.md
+++ b/content/develop/clients/redis-py/amr.md
@@ -26,7 +26,7 @@ letting `redis-entra-id` fetch and renew the authentication tokens for you autom
 
 ## Install
 
-Install [`redis-py`]({{< relref "/develop/clients/redis-py#install" >}}) first,
+Install [`redis-py`](_index.md#install) first,
 if you have not already done so. Then, install `redis-entra-id` with the
 following command:
 
@@ -134,11 +134,11 @@ When you have created your `CredentialProvider` instance, you are ready to
 connect to AMR.
 The example below shows how to pass the instance as a parameter to the standard
 `RedisCluster()` connection method.
-{{< note >}} Azure requires you to use
-[Transport Layer Security (TLS)](https://en.wikipedia.org/wiki/Transport_Layer_Security)
-when you connect (see
-[Connect with TLS]({{< relref "/develop/clients/redis-py/connect#connect-to-your-production-redis-with-tls" >}}) for more information).
-{{< /note >}}
+> [!NOTE]
+> Azure requires you to use
+> [Transport Layer Security (TLS)](https://en.wikipedia.org/wiki/Transport_Layer_Security)
+> when you connect (see
+> [Connect with TLS](connect.md#connect-to-your-production-redis-with-tls) for more information).
 
 ```python
 from redis import RedisCluster
diff --git a/content/develop/clients/redis-py/async.md b/content/develop/clients/redis-py/async.md
index 81a25283c7..a9ad6454a1 100644
--- a/content/develop/clients/redis-py/async.md
+++ b/content/develop/clients/redis-py/async.md
@@ -21,7 +21,7 @@ namespace. It mirrors the synchronous client API, so most code patterns
 translate directly — you `await` commands instead of calling them.
 
 Use the async client for I/O-bound workloads, for integration with async web
-frameworks (such as [FastAPI]({{< relref "/integrate/fastapi" >}}), [Starlette](https://www.starlette.io/), [aiohttp](https://docs.aiohttp.org/en/stable/), or [Sanic](https://sanic.dev/en/), or when you need
+frameworks (such as [FastAPI](../../../integrate/fastapi/_index.md), [Starlette](https://www.starlette.io/), [aiohttp](https://docs.aiohttp.org/en/stable/), or [Sanic](https://sanic.dev/en/), or when you need
 to run many concurrent Redis operations from a single process. For simple
 scripts, CPU-bound work, or codebases without an existing event loop, the
 synchronous client is usually a better choice.
@@ -50,7 +50,7 @@ which ensures `aclose()` runs even if an exception is raised:
 
 For production usage, you should manage connections with a connection pool
 rather than opening and closing them individually.
-See [Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+See [Connection pools and multiplexing](../pools-and-muxing.md)
 for more information about how this works.
 
 A `Redis` client instance already creates and manages its own connection
@@ -93,7 +93,7 @@ through a single connection instead.)
 ## Pipelines and transactions
 
 Pipelines and transactions work the same way as in the synchronous client
-(see [Pipelines and transactions]({{< relref "/develop/clients/redis-py/transpipe" >}})
+(see [Pipelines and transactions](transpipe.md)
 for the conceptual background). The only difference is that you create the
 pipeline inside an `async with` block and `await pipe.execute()`.
 
@@ -125,7 +125,7 @@ consuming task its own subscription.
 
 To connect to a Redis cluster asynchronously, import `RedisCluster` from
 `redis.asyncio.cluster`. The API matches the synchronous cluster client
-(see [Connect to a Redis cluster]({{< relref "/develop/clients/redis-py/connect#connect-to-a-redis-cluster" >}})),
+(see [Connect to a Redis cluster](connect.md#connect-to-a-redis-cluster)),
 with `await` in front of each command.
 
 {{< clients-example set="async_intro" step="cluster" lang_filter="Python" description="Foundational: Connect to a Redis cluster with the async client" difficulty="beginner" >}}
@@ -139,7 +139,7 @@ Always close clients and pools when you're done:
   single scope.
 - For longer-lived clients, call `await r.aclose()` explicitly. (The older
   `close()` method is deprecated.)
-- For frameworks with startup/shutdown hooks — for example [FastAPI]({{< relref "/integrate/fastapi" >}})'s
+- For frameworks with startup/shutdown hooks — for example [FastAPI](../../../integrate/fastapi/_index.md)'s
   `lifespan` — create the client or pool at startup and close it at
   shutdown so connections aren't leaked between process restarts.
 
@@ -178,6 +178,6 @@ client, apply these rules:
 
 - The [`redis-py` asyncio examples](https://redis.readthedocs.io/en/stable/examples/asyncio_examples.html)
   on Read the Docs cover further patterns.
-- See [Error handling]({{< relref "/develop/clients/redis-py/error-handling" >}}) and
-  [Client-side geographic failover]({{< relref "/develop/clients/redis-py/failover" >}}) for
+- See [Error handling](error-handling.md) and
+  [Client-side geographic failover](failover.md) for
   resiliency patterns that apply to both sync and async clients.
diff --git a/content/develop/clients/redis-py/connect.md b/content/develop/clients/redis-py/connect.md
index 7fa8c78a8f..9e34996e8a 100644
--- a/content/develop/clients/redis-py/connect.md
+++ b/content/develop/clients/redis-py/connect.md
@@ -69,7 +69,7 @@ For more information, see [redis-py Clustering](https://redis.readthedocs.io/en/
 
 ## Connect to your production Redis with TLS
 
-When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+When you deploy your application, use TLS and follow the [Redis security](../../../operate/oss_and_stack/management/security/_index.md) guidelines.
 
 ```python
 import redis
@@ -95,14 +95,14 @@ For more information, see [redis-py TLS examples](https://redis.readthedocs.io/e
 
 Client-side caching is a technique to reduce network traffic between
 the client and server, resulting in better performance. See
-[Client-side caching introduction]({{< relref "/develop/clients/client-side-caching" >}})
+[Client-side caching introduction](../client-side-caching.md)
 for more information about how client-side caching works and how to use it effectively.
 
 To enable client-side caching, add some extra parameters when you connect
 to the server:
 
 -   `protocol`: (Required) You must pass a value of `3` here because
-    client-side caching requires the [RESP3]({{< relref "/develop/reference/protocol-spec#resp-versions" >}})
+    client-side caching requires the [RESP3](../../reference/protocol-spec.md#resp-versions)
     protocol.
 -   `cache_config`: (Required) Pass `cache_config=CacheConfig()` here to enable client-side caching.
 
@@ -111,15 +111,15 @@ The example below shows the simplest client-side caching connection to the defau
 All of the connection variants described above accept these parameters, so you can
 use client-side caching with a connection pool or a cluster connection in exactly the same way.
 
-{{< note >}}Client-side caching requires redis-py v5.1.0 or later.
-To maximize compatibility with all Redis products, client-side caching
-is supported by Redis v7.4 or later.
-
-The [Redis server products]({{< relref "/operate" >}}) support
-[opt-in/opt-out]({{< relref "/develop/reference/client-side-caching#opt-in-and-opt-out-caching" >}}) mode
-and [broadcasting mode]({{< relref "/develop/reference/client-side-caching#broadcasting-mode" >}})
-for CSC, but these modes are not currently implemented by `redis-py`.
-{{< /note >}}
+> [!NOTE]
+> Client-side caching requires redis-py v5.1.0 or later.
+> To maximize compatibility with all Redis products, client-side caching
+> is supported by Redis v7.4 or later.
+>
+> The [Redis server products](../../../operate/_index.md) support
+> [opt-in/opt-out](../../reference/client-side-caching.md#opt-in-and-opt-out-caching) mode
+> and [broadcasting mode](../../reference/client-side-caching.md#broadcasting-mode)
+> for CSC, but these modes are not currently implemented by `redis-py`.
 
 ```python
 import redis
@@ -137,8 +137,8 @@ cityNameAttempt2 = r.get("city")    # Retrieved from cache
 ```
 
 You can see the cache working if you connect to the same Redis database
-with [`redis-cli`]({{< relref "/develop/tools/cli" >}}) and run the
-[`MONITOR`]({{< relref "/commands/monitor" >}}) command. If you run the
+with [`redis-cli`](../../tools/cli.md) and run the
+[`MONITOR`](../../../commands/monitor.md) command. If you run the
 code above with the `cache_config` line commented out, you should see
 the following in the CLI among the output from `MONITOR`:
 
@@ -164,8 +164,8 @@ call was satisfied by the cache.
 You can remove individual keys from the cache with the
 `delete_by_redis_keys()` method. This removes all cached items associated
 with the keys, so all results from multi-key commands (such as
-[`MGET`]({{< relref "/commands/mget" >}})) and composite data structures
-(such as [hashes]({{< relref "/develop/data-types/hashes" >}})) will be
+[`MGET`](../../../commands/mget.md)) and composite data structures
+(such as [hashes](../../data-types/hashes.md)) will be
 cleared at once. The example below shows the effect of removing a single
 key from the cache:
 
@@ -219,7 +219,7 @@ one of its open connections. When you subsequently close the same connection,
 it is not actually closed but simply returned to the pool for reuse.
 This avoids the overhead of repeated connecting and disconnecting.
 See
-[Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+[Connection pools and multiplexing](../pools-and-muxing.md)
 for more information.
 
 Use the following code to connect with a connection pool:
@@ -250,7 +250,7 @@ network outage or a server that is temporarily unavailable. In these cases,
 retrying the connection after a short delay will usually succeed. `redis-py` uses
 a simple retry strategy by default, but there are various ways you can customize
 this behavior to suit your use case. See
-[Retries]({{< relref "/develop/clients/redis-py/produsage#retries" >}})
+[Retries](produsage.md#retries)
 for more information about custom retry strategies, with example code.
 
 ## Connect using Smart client handoffs (SCH)
@@ -259,13 +259,13 @@ for more information about custom retry strategies, with example code.
 Redis Software servers that lets them actively notify clients
 about planned server maintenance shortly before it happens. This
 lets a client take action to avoid disruptions in service.
-See [Smart client handoffs]({{< relref "/develop/clients/sch" >}})
+See [Smart client handoffs](../sch.md)
 for more information about SCH.
 
-{{< note >}}Using SCH with redis-py requires v7.0.0 or later for
-basic connections, and v7.2.0 or later for
-[OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}) connections.
-{{< /note >}}
+> [!NOTE]
+> Using SCH with redis-py requires v7.0.0 or later for
+> basic connections, and v7.2.0 or later for
+> [OSS Cluster API](../../../operate/rs/databases/configure/oss-cluster-api.md) connections.
 
 By default, `redis-py` always attempts to connect via SCH but falls back to
 a non-SCH connection if the server doesn't support it. However, you can configure SCH
@@ -299,9 +299,9 @@ r = redis.Redis(
 )
 ```
 
-{{< note >}}SCH requires the [RESP3]({{< relref "/develop/reference/protocol-spec#resp-versions" >}})
-protocol, so you must set `protocol=3` explicitly when you connect.
-{{< /note >}}
+> [!NOTE]
+> SCH requires the [RESP3](../../reference/protocol-spec.md#resp-versions)
+> protocol, so you must set `protocol=3` explicitly when you connect.
 
 The `MaintNotificationsConfig` constructor accepts the following parameters:
 
@@ -312,10 +312,10 @@ The `MaintNotificationsConfig` constructor accepts the following parameters:
 | `endpoint_type` | `EndpointType` | Auto-detect | The type of endpoint to use for the connection. The options are `EndpointType.EXTERNAL_IP`, `EndpointType.INTERNAL_IP`, `EndpointType.EXTERNAL_FQDN`, `EndpointType.INTERNAL_FQDN`, and `EndpointType.NONE`. |
 | `relaxed_timeout` | `int` | `20` | The timeout (in seconds) to use while the server is performing maintenance. A value of `-1` disables the relax timeout and just uses the normal timeout during maintenance. |
 
-{{< note >}} Redis Cloud supports relaxed timeouts *only* (and not pre-handoffs) for SCH if you are using
-either [AWS PrivateLink]({{< relref "/operate/rc/security/aws-privatelink" >}}) or
-[Google Cloud Private Service Connect]({{< relref "/operate/rc/security/private-service-connect" >}})
-(see [Smart client handoffs]({{< relref "/develop/clients/sch#redis-cloud" >}}) for more information).
-To use relaxed timeouts with these services, you should set `endpoint_type=EndpointType.NONE`
-when you connect. All other configurations have full support for both relaxed timeouts and pre-handoffs.
-{{< /note >}}
+> [!NOTE]
+> Redis Cloud supports relaxed timeouts *only* (and not pre-handoffs) for SCH if you are using
+> either [AWS PrivateLink](../../../operate/rc/security/aws-privatelink.md) or
+> [Google Cloud Private Service Connect](../../../operate/rc/security/private-service-connect.md)
+> (see [Smart client handoffs](../sch.md#redis-cloud) for more information).
+> To use relaxed timeouts with these services, you should set `endpoint_type=EndpointType.NONE`
+> when you connect. All other configurations have full support for both relaxed timeouts and pre-handoffs.
diff --git a/content/develop/clients/redis-py/error-handling.md b/content/develop/clients/redis-py/error-handling.md
index 857c097464..2d1ce968d7 100644
--- a/content/develop/clients/redis-py/error-handling.md
+++ b/content/develop/clients/redis-py/error-handling.md
@@ -17,8 +17,8 @@ shows the "happy path" in code examples and omits error handling for brevity.
 This page explains how
 redis-py's error handling works and how to apply common error handling patterns.
 For an overview of error types and handling strategies, see
-[Error handling]({{< relref "/develop/clients/error-handling" >}}).
-See also [Production usage]({{< relref "/develop/clients/redis-py/produsage" >}})
+[Error handling](../error-handling.md).
+See also [Production usage](produsage.md)
 for more information on connection management, timeouts, and other aspects of
 app reliability.
 
@@ -47,7 +47,7 @@ redis-py organizes exceptions in a hierarchy. The base exception is `redis.Redis
 
 The following exceptions are the most commonly encountered in redis-py applications.
 See
-[Categories of errors]({{< relref "/develop/clients/error-handling#categories-of-errors" >}})
+[Categories of errors](../error-handling.md#categories-of-errors)
 for a more detailed discussion of these errors and their causes.
 
 | Exception | When it occurs | Recoverable | Recommended action |
@@ -59,14 +59,14 @@ for a more detailed discussion of these errors and their causes.
 
 ## Applying error handling patterns
 
-The [Error handling]({{< relref "/develop/clients/error-handling" >}}) overview
+The [Error handling](../error-handling.md) overview
 describes four main patterns. The sections below show how to implement them in
 redis-py:
 
 ### Pattern 1: Fail fast
 
 Catch specific exceptions that represent unrecoverable errors and re-raise them (see
-[Pattern 1: Fail fast]({{< relref "/develop/clients/error-handling#pattern-1-fail-fast" >}})
+[Pattern 1: Fail fast](../error-handling.md#pattern-1-fail-fast)
 for a full description):
 
 ```python
@@ -84,7 +84,7 @@ except redis.ResponseError:
 ### Pattern 2: Graceful degradation
 
 Catch connection errors and fall back to an alternative (see
-[Pattern 2: Graceful degradation]({{< relref "/develop/clients/error-handling#pattern-2-graceful-degradation" >}})
+[Pattern 2: Graceful degradation](../error-handling.md#pattern-2-graceful-degradation)
 for a full description):
 
 ```python
@@ -102,18 +102,18 @@ return database.get(key)
 ### Pattern 3: Retry with backoff
 
 Retry on temporary errors like timeouts (see
-[Pattern 3: Retry with backoff]({{< relref "/develop/clients/error-handling#pattern-3-retry-with-backoff" >}})
+[Pattern 3: Retry with backoff](../error-handling.md#pattern-3-retry-with-backoff)
 for a full description). redis-py has built-in retry logic
 which is highly configurable. You can customize the retry strategy
 (or supply your own custom strategy) and you can also specify which errors
 should be retried. See
-[Production usage]({{< relref "/develop/clients/redis-py/produsage#retries" >}})
+[Production usage](produsage.md#retries)
 for more information.
 
 ### Pattern 4: Log and continue
 
 Log non-critical errors and continue (see
-[Pattern 4: Log and continue]({{< relref "/develop/clients/error-handling#pattern-4-log-and-continue" >}})
+[Pattern 4: Log and continue](../error-handling.md#pattern-4-log-and-continue)
 for a full description):
 
 ```python
@@ -145,5 +145,5 @@ async def get_with_fallback(key):
 
 ## See also
 
-- [Error handling]({{< relref "/develop/clients/error-handling" >}})
-- [Production usage]({{< relref "/develop/clients/redis-py/produsage" >}})
+- [Error handling](../error-handling.md)
+- [Production usage](produsage.md)
diff --git a/content/develop/clients/redis-py/failover.md b/content/develop/clients/redis-py/failover.md
index ab0cf0b587..92c09b2f4d 100644
--- a/content/develop/clients/redis-py/failover.md
+++ b/content/develop/clients/redis-py/failover.md
@@ -28,7 +28,7 @@ bannerText: This feature is currently in preview and may be subject to change.
 redis-py supports [Client-side geographic failover](https://en.wikipedia.org/wiki/Failover)
 to improve the availability of connections to Redis databases. This page explains
 how to configure redis-py for failover. For an overview of the concepts,
-see the main [Client-side geographic failover]({{< relref "/develop/clients/failover" >}}) page.
+see the main [Client-side geographic failover](../failover.md) page.
 
 ## Failover configuration
 
@@ -38,7 +38,7 @@ target. If `redis-east` fails, redis-py should fail over to
 `redis-west`.
 
 Supply the weighted endpoints using a list of `DatabaseConfig` objects
-(see [Selecting a failover target]({{< relref "/develop/clients/failover#selecting-a-failover-target" >}}) for a full description of how
+(see [Selecting a failover target](../failover.md#selecting-a-failover-target) for a full description of how
 the weighted list is used).
 Use the `weight` option to order the endpoints, with the highest
 weight being tried first. Then, use the list to create a `MultiDbConfig` object,
@@ -74,9 +74,9 @@ constructor in the `databases_config` parameter.
 
 | Option | Description |
 | --- | --- |
-| `client_kwargs` | Keyword parameters to pass to the internal client constructor for this endpoint. Use it to specify the host, port, username, password, and other connection parameters (see [Connect to the server]({{< relref "/develop/clients/redis-py/connect" >}}) for more information). This is especially useful if you are using a custom client class (see [Client configuration](#client-configuration) below for more information). |
+| `client_kwargs` | Keyword parameters to pass to the internal client constructor for this endpoint. Use it to specify the host, port, username, password, and other connection parameters (see [Connect to the server](connect.md) for more information). This is especially useful if you are using a custom client class (see [Client configuration](#client-configuration) below for more information). |
 | `from_url` | Redis URL to connect to this endpoint, as an alternative to passing the host and port in `client_kwargs`. |
-| `from_pool` | A `ConnectionPool` to supply the endpoint connection (see [Connect with a connection pool]({{< relref "/develop/clients/redis-py/connect#connect-with-a-connection-pool" >}}) for more information) |
+| `from_pool` | A `ConnectionPool` to supply the endpoint connection (see [Connect with a connection pool](connect.md#connect-with-a-connection-pool) for more information) |
 | `weight` | Priority of the endpoint, with higher values being tried first. Default is `1.0`. |
 | `grace_period` | Duration in seconds to keep an unhealthy endpoint disabled before attempting a failback. Default is `60` seconds. |
 | `health_check_url` | URL for health checks that use the database's REST API (see [`LagAwareHealthCheck`](#lag-aware-health-check) for more information). |
@@ -97,7 +97,7 @@ cfg = MultiDbConfig(
 ### Circuit breaker configuration
 
 `MultiDbConfig` gives you several options to configure the circuit breaker
-(see [Detecting connection problems]({{< relref "/develop/clients/failover#detecting-connection-problems" >}}) for more information on how the
+(see [Detecting connection problems](../failover.md#detecting-connection-problems) for more information on how the
 circuit breaker works):
 
 | Option | Description |
@@ -109,7 +109,7 @@ circuit breaker works):
 ### Retry configuration
 
 `MultiDbConfig` provides the `command_retry` option to configure retries for failed commands. This follows the usual approach to configuring retries used with a standard
-`RedisClient` connection (see [Retries]({{< relref "/develop/clients/redis-py/produsage#retries" >}}) for more information).
+`RedisClient` connection (see [Retries](produsage.md#retries) for more information).
 
 ```py
 cfg = MultiDbConfig(
@@ -194,7 +194,7 @@ client = MultiDBClient(config)
 ## Health check configuration
 
 Each health check consists of one or more separate "probes", each of which is a simple
-test (such as a [`PING`]({{< relref "/commands/ping" >}}) command) to determine if the
+test (such as a [`PING`](../../../commands/ping.md) command) to determine if the
 database is available. The results of the separate probes are combined
 using a configurable policy to determine if the database is healthy.
 
@@ -223,7 +223,7 @@ in more detail.
 ### `PingHealthCheck` (default)
 
 The default strategy, `PingHealthCheck`, periodically sends a Redis
-[`PING`]({{< relref "/commands/ping" >}}) command
+[`PING`](../../../commands/ping.md) command
 and checks that it gives the expected response. Any unexpected response
 or exception indicates an unhealthy server. Although `PingHealthCheck` is
 very simple, it is a good basic approach for most Redis deployments.
@@ -231,9 +231,9 @@ very simple, it is a good basic approach for most Redis deployments.
 ### `LagAwareHealthCheck` (Redis Software only) {#lag-aware-health-check}
 
 `LagAwareHealthCheck` is designed specifically for
-Redis Software [Active-Active]({{< relref "/operate/rs/databases/active-active" >}})
+Redis Software [Active-Active](../../../operate/rs/databases/active-active/_index.md)
 deployments. It determines the health of the server by using the
-[REST API]({{< relref "/operate/rs/references/rest-api" >}}) to check the
+[REST API](../../../operate/rs/references/rest-api/_index.md) to check the
 synchronization lag between a specific database and the others in the Active-Active
 setup. If the lag is within a specified tolerance, the server is considered healthy.
 
@@ -305,7 +305,7 @@ Note that health checks are executed in an asyncio event loop, so you
 must implement the `check_health()` method as an async method.
 
 The example below
-shows a simple custom strategy that sends a Redis [`ECHO`]({{< relref "/commands/echo" >}})
+shows a simple custom strategy that sends a Redis [`ECHO`](../../../commands/echo.md)
 command and checks for the expected response.
 
 ```py
@@ -391,7 +391,7 @@ If you decide to implement manual failback, you will need a way for external sys
 
 ## Pub/Sub and re-subscription
 
-`MultiDBClient` supports [Pub/Sub]({{< relref "/develop/pubsub" >}})
+`MultiDBClient` supports [Pub/Sub](../../pubsub/_index.md)
 messaging with automatic re-subscription to channels during failover.
 This means you don't have to detect failovers and re-subscribe manually:
 
@@ -420,11 +420,11 @@ if msg:
 Re-subscription happens transparently and is independent of any custom
 event listeners you register (see [Failover callbacks](#failover-callbacks)).
 
-{{< note >}}Message loss can still occur if the failover events happen in
-the reverse order, with the publisher failing over to the new database
-before the subscriber. Messages published during this window may not reach
-a subscriber that is still connected to the previous database.
-{{< /note >}}
+> [!NOTE]
+> Message loss can still occur if the failover events happen in
+> the reverse order, with the publisher failing over to the new database
+> before the subscriber. Messages published during this window may not reach
+> a subscriber that is still connected to the previous database.
 
 ## Behavior when all endpoints are unhealthy
 
@@ -436,7 +436,7 @@ gives a period of 120 seconds to find a healthy endpoint.
 
 You can still keep retrying commands after a `TemporaryUnavailableException` is thrown (for example,
 you could add this exception to the `supported_errors` list in your `Retry` configuration, as described
-in [Retries]({{< relref "/develop/clients/redis-py/produsage#retries" >}})). However, if the client exhausts
+in [Retries](produsage.md#retries)). However, if the client exhausts
 all the available failover attempts before any endpoint becomes healthy again, commands will throw a `NoValidDatabaseException`. The client won't recover automatically from this situation, so you
 should handle it by reconnecting with the `MultiDBClient` constructor after a suitable delay (see
 [Failover configuration](#failover-configuration) for a connection example).
@@ -454,7 +454,7 @@ network connectivity problems.
 If you are using [`PingHealthCheck`](#pinghealthcheck-default) or a
 [custom health check strategy](#custom-health-check-strategy),
 check that the `socket_timeout` is not too low for your network conditions
-(see [Timeouts]({{< relref "/develop/clients/redis-py/produsage#timeouts" >}}) for more information).
+(see [Timeouts](produsage.md#timeouts) for more information).
 
 For
 [`LagAwareHealthCheck`](#lag-aware-health-check), check that the `health_check_url`
diff --git a/content/develop/clients/redis-py/observability.md b/content/develop/clients/redis-py/observability.md
index 6523724d8c..6a30e56158 100644
--- a/content/develop/clients/redis-py/observability.md
+++ b/content/develop/clients/redis-py/observability.md
@@ -19,7 +19,7 @@ weight: 75
 instrumentation to collect metrics. This can be very helpful for
 diagnosing problems and improving the performance and connection resiliency of
 your application. See the
-[Observability overview]({{< relref "/develop/clients/observability" >}})
+[Observability overview](../observability.md)
 for an introduction to Redis client observability and a reference guide for the
 available metrics.
 
@@ -69,15 +69,15 @@ The available options for `OTelConfig` are described in the table below:
 
 | Option | Type | Description |
 | --- | --- | --- |
-| `metric_groups` | `List[MetricGroup]` | List of metric groups to enable. By default, only `CONNECTION_BASIC` and `RESILIENCY` are enabled. See [Redis metric groups]({{< relref "/develop/clients/observability#redis-metric-groups" >}}) for a list of available groups. |
+| `metric_groups` | `List[MetricGroup]` | List of metric groups to enable. By default, only `CONNECTION_BASIC` and `RESILIENCY` are enabled. See [Redis metric groups](../observability.md#redis-metric-groups) for a list of available groups. |
 | `include_commands` | `List[str]` | List of Redis commands to track. If set, only these commands will be tracked. Note that you should use the Redis command name rather than the Python method name where the two differ. |
 | `exclude_commands` | `List[str]` | List of Redis commands to exclude from tracking. If set, all commands except these will be tracked. Note that you should use the Redis command name rather than the Python method name where the two differ. |
 | `hide_pubsub_channel_names` | `bool` | If true, channel names in pub/sub metrics will be hidden. |
 | `hide_stream_names` | `bool` | If true, stream names in streaming metrics will be hidden. |
-| `buckets_operation_duration` | `List[float]` | List of bucket boundaries for the [`operation.duration`]({{< relref "/develop/clients/observability/#metric-db.client.operation.duration" >}}) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
-| `buckets_stream_processing_duration` | `List[float]` | List of bucket boundaries for the [`stream.lag`]({{< relref "/develop/clients/observability/#metric-redis.client.stream.lag" >}}) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
-| `buckets_connection_create_time` | `List[float]` | List of bucket boundaries for the [`connection.create.time`]({{< relref "/develop/clients/observability/#metric-db.client.connection.create_time" >}}) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
-| `buckets_connection_wait_time` | `List[float]` | List of bucket boundaries for the [`connection.wait.time`]({{< relref "/develop/clients/observability/#metric-db.client.connection.wait_time" >}}) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
+| `buckets_operation_duration` | `List[float]` | List of bucket boundaries for the [`operation.duration`](../observability.md#metric-db.client.operation.duration) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
+| `buckets_stream_processing_duration` | `List[float]` | List of bucket boundaries for the [`stream.lag`](../observability.md#metric-redis.client.stream.lag) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
+| `buckets_connection_create_time` | `List[float]` | List of bucket boundaries for the [`connection.create.time`](../observability.md#metric-db.client.connection.create_time) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
+| `buckets_connection_wait_time` | `List[float]` | List of bucket boundaries for the [`connection.wait.time`](../observability.md#metric-db.client.connection.wait_time) histogram (see [Custom histogram buckets](#custom-histogram-buckets) below). |
 
 ### Custom histogram buckets
 
diff --git a/content/develop/clients/redis-py/prob.md b/content/develop/clients/redis-py/prob.md
index 6c38564fae..f0ada19d6d 100644
--- a/content/develop/clients/redis-py/prob.md
+++ b/content/develop/clients/redis-py/prob.md
@@ -16,7 +16,7 @@ weight: 45
 ---
 
 Redis supports several
-[probabilistic data types]({{< relref "/develop/data-types/probabilistic" >}})
+[probabilistic data types](../../data-types/probabilistic/_index.md)
 that let you calculate values approximately rather than exactly.
 The types fall into two basic categories:
 
@@ -32,7 +32,7 @@ counting the number of distinct IP addresses that access a website in one day.
 
 Assuming that you already have code that supplies you with each IP
 address as a string, you could record the addresses in Redis using
-a [set]({{< relref "/develop/data-types/sets" >}}):
+a [set](../../data-types/sets.md):
 
 ```py
 r.sadd("ip_tracker", new_ip_address)
@@ -68,11 +68,11 @@ time than the equivalent precise calculations.
 Redis supports the following approximate set operations:
 
 -   [Membership](#set-membership): The
-    [Bloom filter]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}}) and
-    [Cuckoo filter]({{< relref "/develop/data-types/probabilistic/cuckoo-filter" >}})
+    [Bloom filter](../../data-types/probabilistic/bloom-filter.md) and
+    [Cuckoo filter](../../data-types/probabilistic/cuckoo-filter.md)
     data types let you track whether or not a given item is a member of a set.
 -   [Cardinality](#set-cardinality): The
-    [HyperLogLog]({{< relref "/develop/data-types/probabilistic/hyperloglogs" >}})
+    [HyperLogLog](../../data-types/probabilistic/hyperloglogs.md)
     data type gives you an approximate value for the number of items in a set, also
     known as the *cardinality* of the set.
 
@@ -80,8 +80,8 @@ The sections below describe these operations in more detail.
 
 ### Set membership
 
-[Bloom filter]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}}) and
-[Cuckoo filter]({{< relref "/develop/data-types/probabilistic/cuckoo-filter" >}})
+[Bloom filter](../../data-types/probabilistic/bloom-filter.md) and
+[Cuckoo filter](../../data-types/probabilistic/cuckoo-filter.md)
 objects provide a set membership operation that lets you track whether or not a
 particular item has been added to a set. These two types provide different
 trade-offs for memory usage and speed, so you can select the best one for your
@@ -90,7 +90,7 @@ absence of items in the set. If an item is reported as absent, then it is defini
 absent, but if it is reported as present, then there is a small chance it may really be
 absent.
 
-Instead of storing strings directly, like a [set]({{< relref "/develop/data-types/sets" >}}),
+Instead of storing strings directly, like a [set](../../data-types/sets.md),
 a Bloom filter records the presence or absence of the
 [hash value](https://en.wikipedia.org/wiki/Hash_function) of a string.
 This gives a very compact representation of the
@@ -114,13 +114,13 @@ Which of these two data types you choose depends on your use case.
 Bloom filters are generally faster than Cuckoo filters when adding new items,
 and also have better memory usage. Cuckoo filters are generally faster
 at checking membership and also support the delete operation. See the
-[Bloom filter]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}}) and
-[Cuckoo filter]({{< relref "/develop/data-types/probabilistic/cuckoo-filter" >}})
+[Bloom filter](../../data-types/probabilistic/bloom-filter.md) and
+[Cuckoo filter](../../data-types/probabilistic/cuckoo-filter.md)
 reference pages for more information and comparison between the two types.
 
 ### Set cardinality
 
-A [HyperLogLog]({{< relref "/develop/data-types/probabilistic/hyperloglogs" >}})
+A [HyperLogLog](../../data-types/probabilistic/hyperloglogs.md)
 object calculates the cardinality of a set. As you add
 items, the HyperLogLog tracks the number of distinct set members but
 doesn't let you retrieve them or query which items have been added.
@@ -144,20 +144,20 @@ Redis supports several approximate statistical calculations
 on numeric data sets:
 
 -   [Frequency](#frequency): The
-    [Count-min sketch]({{< relref "/develop/data-types/probabilistic/count-min-sketch" >}})
+    [Count-min sketch](../../data-types/probabilistic/count-min-sketch.md)
     data type lets you find the approximate frequency of a labeled item in a data stream.
 -   [Quantiles](#quantiles): The
-    [t-digest]({{< relref "/develop/data-types/probabilistic/t-digest" >}})
+    [t-digest](../../data-types/probabilistic/t-digest.md)
     data type estimates the quantile of a query value in a data stream.
 -   [Ranking](#ranking): The
-    [Top-K]({{< relref "/develop/data-types/probabilistic/top-k" >}}) data type
+    [Top-K](../../data-types/probabilistic/top-k.md) data type
     estimates the ranking of labeled items by frequency in a data stream.
 
 The sections below describe these operations in more detail.
 
 ### Frequency
 
-A [Count-min sketch]({{< relref "/develop/data-types/probabilistic/count-min-sketch" >}})
+A [Count-min sketch](../../data-types/probabilistic/count-min-sketch.md)
 (CMS) object keeps count of a set of related items represented by
 string labels. The count is approximate, but you can specify
 how close you want to keep the count to the true value (as a fraction)
@@ -173,7 +173,7 @@ sketch commands.
 {{< /clients-example >}}
 
 The advantage of using a CMS over keeping an exact count with a
-[sorted set]({{< relref "/develop/data-types/sorted-sets" >}})
+[sorted set](../../data-types/sorted-sets.md)
 is that that a CMS has very low and fixed memory usage, even for
 large numbers of items. Use CMS objects to keep daily counts of
 items sold, accesses to individual web pages on your site, and
@@ -188,7 +188,7 @@ the value of height below which 75% of all people's heights lie.
 [Percentiles](https://en.wikipedia.org/wiki/Percentile) are equivalent
 to quantiles, except that the fraction is expressed as a percentage.
 
-A [t-digest]({{< relref "/develop/data-types/probabilistic/t-digest" >}})
+A [t-digest](../../data-types/probabilistic/t-digest.md)
 object can estimate quantiles from a set of values added to it
 without having to store each value in the set explicitly. This can
 save a lot of memory when you have a large number of samples.
@@ -207,12 +207,12 @@ t-digest commands.
 
 A t-digest object also supports several other related commands, such
 as querying by rank. See the
-[t-digest]({{< relref "/develop/data-types/probabilistic/t-digest" >}})
+[t-digest](../../data-types/probabilistic/t-digest.md)
 reference for more information.
 
 ### Ranking
 
-A [Top-K]({{< relref "/develop/data-types/probabilistic/top-k" >}})
+A [Top-K](../../data-types/probabilistic/top-k.md)
 object estimates the rankings of different labeled items in a data
 stream according to frequency. For example, you could use this to
 track the top ten most frequently-accessed pages on a website, or the
diff --git a/content/develop/clients/redis-py/produsage.md b/content/develop/clients/redis-py/produsage.md
index c43aa07ab1..dea7b497d3 100644
--- a/content/develop/clients/redis-py/produsage.md
+++ b/content/develop/clients/redis-py/produsage.md
@@ -41,12 +41,12 @@ of them may not apply to your particular use case.
 
 ### Client-side caching
 
-[Client-side caching]({{< relref "/develop/clients/client-side-caching" >}})
+[Client-side caching](../client-side-caching.md)
 involves storing the results from read-only commands in a local cache. If the
 same command is executed again later, the results can be obtained from the cache,
 without contacting the server. This improves command execution time on the client,
 while also reducing network traffic and server load. See
-[Connect using client-side caching]({{< relref "/develop/clients/redis-py/connect#connect-using-client-side-caching" >}})
+[Connect using client-side caching](connect.md#connect-using-client-side-caching)
 for more information and example code.
 
 ### Retries
@@ -128,7 +128,7 @@ Set the `health_check_interval` parameter during
 a connection (with either `Redis` or `ConnectionPool`) to specify
 an integer number of seconds. If the connection remains idle for
 longer than this interval, it will automatically issue a
-[`PING`]({{< relref "/commands/ping" >}}) command and check the
+[`PING`](../../../commands/ping.md) command and check the
 response before continuing with any client commands.
 
 ```py
@@ -163,15 +163,15 @@ module. The list below describes some of the most common exceptions.
 - `ResponseError`: Thrown when you attempt an operation that has no valid
   response. Examples include executing a command on the wrong type of key
   (as when you try an
-  ['LPUSH']({{< relref "/develop/data-types/lists#automatic-creation-and-removal-of-keys" >}})
+  ['LPUSH'](../../data-types/lists.md#automatic-creation-and-removal-of-keys)
   command on a string key), creating an
-  [index]({{< relref "/develop/ai/search-and-query/indexing" >}})
+  [index](../../ai/search-and-query/indexing/_index.md)
   with a name that already exists, and using an invalid ID for a
-  [stream entry]({{< relref "/develop/data-types/streams/#entry-ids" >}}).
+  [stream entry](../../data-types/streams/_index.md#entry-ids).
 - `TimeoutError`: Thrown when a timeout persistently happens for a command,
   despite any [retries](#retries).
 - `WatchError`: Thrown when a
-  [watched key]({{< relref "/develop/clients/redis-py/transpipe#watch-keys-for-changes" >}}) is
+  [watched key](transpipe.md#watch-keys-for-changes) is
   modified during a transaction.
 
 ### Timeouts
@@ -207,9 +207,9 @@ Redis Software servers that lets them actively notify clients
 about planned server maintenance shortly before it happens. This
 lets a client take action to avoid disruptions in service.
 
-See [Smart client handoffs]({{< relref "/develop/clients/sch" >}})
+See [Smart client handoffs](../sch.md)
 for more information about SCH and
-[Connect using Smart client handoffs]({{< relref "/develop/clients/redis-py/connect#connect-using-smart-client-handoffs-sch" >}})
+[Connect using Smart client handoffs](connect.md#connect-using-smart-client-handoffs-sch)
 for example code.
 
 ### Monitor performance and errors
@@ -217,5 +217,5 @@ for example code.
 `redis-py` supports [OpenTelemetry](https://opentelemetry.io/). This lets
 you trace command execution and monitor your server's performance.
 You can use this information to detect problems before they are reported
-by users. See [Observability]({{< relref "/develop/clients/redis-py/observability" >}})
+by users. See [Observability](observability.md)
 for more information.
\ No newline at end of file
diff --git a/content/develop/clients/redis-py/queryjson.md b/content/develop/clients/redis-py/queryjson.md
index 016461dcad..223cb440be 100644
--- a/content/develop/clients/redis-py/queryjson.md
+++ b/content/develop/clients/redis-py/queryjson.md
@@ -24,31 +24,31 @@ weight: 30
 ---
 
 This example shows how to create a
-[search index]({{< relref "/develop/ai/search-and-query/indexing" >}})
-for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+[search index](../../ai/search-and-query/indexing/_index.md)
+for [JSON](../../data-types/json/_index.md) documents and
 run queries against the index. It then goes on to show the slight differences
-in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+in the equivalent code for [hash](../../data-types/hashes.md)
 documents.
 
-{{< note >}}From [v6.0.0](https://github.com/redis/redis-py/releases/tag/v6.0.0) onwards,
-`redis-py` uses query dialect 2 by default.
-Redis Search methods such as [`ft().search()`]({{< relref "/commands/ft.search" >}})
-will explicitly request this dialect, overriding the default set for the server.
-See
-[Query dialects]({{< relref "/develop/ai/search-and-query/advanced-concepts/dialects" >}})
-for more information.
-{{< /note >}}
+> [!NOTE]
+> From [v6.0.0](https://github.com/redis/redis-py/releases/tag/v6.0.0) onwards,
+> `redis-py` uses query dialect 2 by default.
+> Redis Search methods such as [`ft().search()`](../../../commands/ft.search.md)
+> will explicitly request this dialect, overriding the default set for the server.
+> See
+> [Query dialects](../../ai/search-and-query/advanced-concepts/dialects.md)
+> for more information.
 
 ## Initialize
 
-Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+Make sure that you have [Redis Open Source](../../../operate/oss_and_stack/_index.md)
 or another Redis server available. Also install the
-[`redis-py`]({{< relref "/develop/clients/redis-py" >}}) client library if you
+[`redis-py`](_index.md) client library if you
 haven't already done so.
 
 Add the following dependencies. All of them are applicable to both JSON and hash,
 except for the `Path` class, which is specific to JSON (see
-[Path]({{< relref "/develop/data-types/json/path" >}}) for a description of the
+[Path](../../data-types/json/path.md) for a description of the
 JSON path syntax).
 
 {{< jupyter-example set="py_home_json" lang_filter="Python" step="import" description="Foundational: Import required libraries for Redis Search, JSON operations, and search functionality" difficulty="beginner" />}}
@@ -64,7 +64,7 @@ below is compatible with both JSON and hash objects.
 
 Connect to your Redis database. The code below shows the most
 basic connection but see
-[Connect to the server]({{< relref "/develop/clients/redis-py/connect" >}})
+[Connect to the server](connect.md)
 to learn more about the available connection options.
 
 {{< jupyter-example set="py_home_json" lang_filter="Python" step="connect" depends="import" description="Foundational: Establish a connection to a Redis server for query operations" difficulty="beginner" />}}
@@ -78,14 +78,14 @@ conflict with the example:
 
 Create an index for the JSON data. The code below specifies that only JSON documents with
 the key prefix `user:` are indexed. For more information, see
-[Query syntax]({{< relref "/develop/ai/search-and-query/query/" >}}).
+[Query syntax](../../ai/search-and-query/query/_index.md).
 
 {{< jupyter-example set="py_home_json" lang_filter="Python" step="make_index" depends="import" description="Foundational: Create a search index for JSON documents with field definitions and key prefix filtering" difficulty="intermediate" />}}
 
 ## Add the data
 
 Add the three sets of user data to the database as
-[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+[JSON](../../data-types/json/_index.md) objects.
 If you use keys with the `user:` prefix then Redis will index the
 objects automatically as you add them:
 
@@ -94,7 +94,7 @@ objects automatically as you add them:
 ## Query the data
 
 You can now use the index to search the JSON objects. The
-[query]({{< relref "/develop/ai/search-and-query/query" >}})
+[query](../../ai/search-and-query/query/_index.md)
 below searches for objects that have the text "Paul" in any field
 and have an `age` value in the range 30 to 40:
 
@@ -107,7 +107,7 @@ Specify query options to return only the `city` field:
 
 
 Use an
-[aggregation query]({{< relref "/develop/ai/search-and-query/query/aggregation" >}})
+[aggregation query](../../ai/search-and-query/query/aggregation.md)
 to count all users in each city.
 
 {{< jupyter-example set="py_home_json" lang_filter="Python" step="query3" depends="import" description="Aggregation queries: Use GROUP BY and COUNT operations to summarize and analyze indexed data" difficulty="advanced" />}}
@@ -134,8 +134,8 @@ the `idx:users` index used for JSON documents in the previous examples:
 {{< jupyter-example set="py_home_json" lang_filter="Python" step="make_hash_index" depends="import" description="Foundational: Create a search index for hash documents with HASH index type and field definitions" difficulty="intermediate" />}}
 
 
-You use [`hset()`]({{< relref "/commands/hset" >}}) to add the hash
-documents instead of [`json().set()`]({{< relref "/commands/json.set" >}}),
+You use [`hset()`](../../../commands/hset.md) to add the hash
+documents instead of [`json().set()`](../../../commands/json.set.md),
 but the same flat `userX` dictionaries work equally well with either
 hash or JSON:
 
@@ -150,5 +150,5 @@ result `Document` object instead of in an enclosing `json` dictionary:
 
 ## More information
 
-See the [Redis Search]({{< relref "/develop/ai/search-and-query" >}}) docs
+See the [Redis Search](../../ai/search-and-query/_index.md) docs
 for a full description of all query features with examples.
diff --git a/content/develop/clients/redis-py/scaniter.md b/content/develop/clients/redis-py/scaniter.md
index 0898ae66f6..674ddc3ead 100644
--- a/content/develop/clients/redis-py/scaniter.md
+++ b/content/develop/clients/redis-py/scaniter.md
@@ -18,15 +18,15 @@ weight: 60
 Redis has a small family of related commands that retrieve
 keys and, in some cases, their associated values:
 
--   [`SCAN`]({{< relref "/commands/scan" >}}) retrieves keys
+-   [`SCAN`](../../../commands/scan.md) retrieves keys
     from the main Redis keyspace.
--   [`HSCAN`]({{< relref "/commands/hscan" >}}) retrieves keys and optionally,
+-   [`HSCAN`](../../../commands/hscan.md) retrieves keys and optionally,
     their values from a
-    [hash]({{< relref "/develop/data-types/hashes" >}}) object.
--   [`SSCAN`]({{< relref "/commands/sscan" >}}) retrieves keys from a
-    [set]({{< relref "/develop/data-types/sets" >}}) object.
--   [`ZSCAN`]({{< relref "/commands/zscan" >}}) retrieves keys and their score values from a
-    [sorted set]({{< relref "/develop/data-types/sorted-sets" >}}) object.
+    [hash](../../data-types/hashes.md) object.
+-   [`SSCAN`](../../../commands/sscan.md) retrieves keys from a
+    [set](../../data-types/sets.md) object.
+-   [`ZSCAN`](../../../commands/zscan.md) retrieves keys and their score values from a
+    [sorted set](../../data-types/sorted-sets.md) object.
 
 These commands can potentially return large numbers of results, so Redis
 provides a paging mechanism to access the results in small, separate batches.
@@ -43,7 +43,7 @@ Each of the commands has its own equivalent iterator. The following example show
 how to use a `SCAN` iterator on the Redis keyspace. Note that, as with the `SCAN`
 command, the results are not sorted into any particular order, . Also, you
 can pass `match`, `count`, and `_type` parameters to `scan_iter()` to constrain
-the set of keys it returns (see the [`SCAN`]({{< relref "/commands/scan" >}})
+the set of keys it returns (see the [`SCAN`](../../../commands/scan.md)
 command page for examples). 
 
 ```py
diff --git a/content/develop/clients/redis-py/transpipe.md b/content/develop/clients/redis-py/transpipe.md
index 0727510569..81d761de2f 100644
--- a/content/develop/clients/redis-py/transpipe.md
+++ b/content/develop/clients/redis-py/transpipe.md
@@ -21,11 +21,11 @@ There are two types of batch that you can use:
 -   **Pipelines** avoid network and processing overhead by sending several commands
     to the server together in a single communication. The server then sends back
     a single communication with all the responses. See the
-    [Pipelining]({{< relref "/develop/using-commands/pipelining" >}}) page for more
+    [Pipelining](../../using-commands/pipelining.md) page for more
     information.
 -   **Transactions** guarantee that all the included commands will execute
     to completion without being interrupted by commands from other clients.
-    See the [Transactions]({{< relref "develop/using-commands/transactions" >}})
+    See the [Transactions](../../using-commands/transactions.md)
     page for more information.
 
 ## Execute a pipeline
@@ -62,7 +62,7 @@ to different keys. The basic idea is to watch for changes to any
 keys that you use in a transaction while you are processing the
 updates. If the watched keys do change, you must restart the updates
 with the latest data from the keys. See
-[Transactions]({{< relref "develop/using-commands/transactions" >}})
+[Transactions](../../using-commands/transactions.md)
 for more information about optimistic locking.
 
 The example below shows how to repeatedly attempt a transaction with a watched
diff --git a/content/develop/clients/redis-py/vecsearch.md b/content/develop/clients/redis-py/vecsearch.md
index 9db40daf73..c5d91e3883 100644
--- a/content/develop/clients/redis-py/vecsearch.md
+++ b/content/develop/clients/redis-py/vecsearch.md
@@ -25,14 +25,14 @@ topics:
 weight: 40
 ---
 
-[Redis Search]({{< relref "/develop/ai/search-and-query" >}})
-lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
-or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
-[Vectors]({{< relref "/develop/ai/search-and-query/vectors" >}}) 
+[Redis Search](../../ai/search-and-query/_index.md)
+lets you index vector fields in [hash](../../data-types/hashes.md)
+or [JSON](../../data-types/json/_index.md) objects (see the
+[Vectors](../../ai/search-and-query/vectors/_index.md) 
 reference page for more information).
 Among other things, vector fields can store *text embeddings*, which are AI-generated vector
 representations of the semantic information in pieces of text. The
-[vector distance]({{< relref "/develop/ai/search-and-query/vectors#distance-metrics" >}})
+[vector distance](../../ai/search-and-query/vectors/_index.md#distance-metrics)
 between two embeddings indicates how similar they are semantically. By comparing the
 similarity of an embedding generated from some query text with embeddings stored in hash
 or JSON fields, Redis can retrieve documents that closely match the query in terms
@@ -45,18 +45,18 @@ Redis Search. The code is first demonstrated for hash documents with a
 separate section to explain the
 [differences with JSON documents](#differences-with-json-documents).
 
-{{< note >}}From [v6.0.0](https://github.com/redis/redis-py/releases/tag/v6.0.0) onwards,
-`redis-py` uses query dialect 2 by default.
-Redis Search methods such as [`ft().search()`]({{< relref "/commands/ft.search" >}})
-will explicitly request this dialect, overriding the default set for the server.
-See
-[Query dialects]({{< relref "/develop/ai/search-and-query/advanced-concepts/dialects" >}})
-for more information.
-{{< /note >}}
+> [!NOTE]
+> From [v6.0.0](https://github.com/redis/redis-py/releases/tag/v6.0.0) onwards,
+> `redis-py` uses query dialect 2 by default.
+> Redis Search methods such as [`ft().search()`](../../../commands/ft.search.md)
+> will explicitly request this dialect, overriding the default set for the server.
+> See
+> [Query dialects](../../ai/search-and-query/advanced-concepts/dialects.md)
+> for more information.
 
 ## Initialize
 
-Install [`redis-py`]({{< relref "/develop/clients/redis-py" >}}) if you
+Install [`redis-py`](_index.md) if you
 have not already done so. Also, install `sentence-transformers` with the
 following command:
 
@@ -96,12 +96,12 @@ the index doesn't already exist, which is why you need the
 Next, create the index.
 The schema in the example below specifies hash objects for storage and includes
 three fields: the text content to index, a
-[tag]({{< relref "/develop/ai/search-and-query/advanced-concepts/tags" >}})
+[tag](../../ai/search-and-query/advanced-concepts/tags.md)
 field to represent the "genre" of the text, and the embedding vector generated from
 the original text content. The `embedding` field specifies
-[HNSW]({{< relref "/develop/ai/search-and-query/vectors#hnsw-index" >}})
+[HNSW](../../ai/search-and-query/vectors/_index.md#hnsw-index)
 indexing, the
-[L2]({{< relref "/develop/ai/search-and-query/vectors#distance-metrics" >}})
+[L2](../../ai/search-and-query/vectors/_index.md#distance-metrics)
 vector distance metric, `Float32` values to represent the vector's components,
 and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
 
@@ -111,7 +111,7 @@ and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
 ## Add data
 
 You can now supply the data objects, which will be indexed automatically
-when you add them with [`hset()`]({{< relref "/commands/hset" >}}), as long as
+when you add them with [`hset()`](../../../commands/hset.md), as long as
 you use the `doc:` prefix specified in the index definition.
 
 Use the `model.encode()` method of `SentenceTransformer`
@@ -137,7 +137,7 @@ results in order of this numeric similarity value.
 The code below creates the query embedding using `model.encode()`, as with
 the indexing, and passes it as a parameter when the query executes
 (see
-[Vector search]({{< relref "/develop/ai/search-and-query/query/vector-search" >}})
+[Vector search](../../ai/search-and-query/query/vector-search.md)
 for more information about using query parameters with embeddings).
 
 {{< clients-example set="home_query_vec" step="query" lang_filter="Python" description="Vector similarity search: Find semantically similar documents by comparing query embeddings with indexed vectors using L2 distance" difficulty="intermediate" >}}
@@ -185,7 +185,7 @@ is the result that is most similar in meaning to the query text
 
 Indexing JSON documents is similar to hash indexing, but there are some
 important differences. JSON allows much richer data modelling with nested fields, so
-you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+you must supply a [path](../../data-types/json/path.md) in the schema
 to identify each field you want to index. However, you can declare a short alias for each
 of these paths (using the `as_name` keyword argument) to avoid typing it in full for
 every query. Also, you must specify `IndexType.JSON` when you create the index.
@@ -196,8 +196,8 @@ the one created previously for hashes:
 {{< clients-example set="home_query_vec" step="json_index" lang_filter="Python" description="Foundational: Create a vector search index for JSON documents with JSON paths and field aliases" difficulty="intermediate" >}}
 {{< /clients-example >}}
 
-Use [`json().set()`]({{< relref "/commands/json.set" >}}) to add the data
-instead of [`hset()`]({{< relref "/commands/hset" >}}). The dictionaries
+Use [`json().set()`](../../../commands/json.set.md) to add the data
+instead of [`hset()`](../../../commands/hset.md). The dictionaries
 that specify the fields have the same structure as the ones used for `hset()`
 but `json().set()` receives them in a positional argument instead of
 the `mapping` keyword argument.
@@ -241,6 +241,6 @@ Result{
 ## Learn more
 
 See
-[Vector search]({{< relref "/develop/ai/search-and-query/query/vector-search" >}})
+[Vector search](../../ai/search-and-query/query/vector-search.md)
 for more information about the indexing options, distance metrics, and query format
 for vectors.
diff --git a/content/develop/clients/redis-py/vecsets.md b/content/develop/clients/redis-py/vecsets.md
index 3d7f9db191..8e1ea3d8d2 100644
--- a/content/develop/clients/redis-py/vecsets.md
+++ b/content/develop/clients/redis-py/vecsets.md
@@ -21,14 +21,14 @@ topics:
 - vectors
 ---
 
-A Redis [vector set]({{< relref "/develop/data-types/vector-sets" >}}) lets
+A Redis [vector set](../../data-types/vector-sets/_index.md) lets
 you store a set of unique keys, each with its own associated vector.
 You can then retrieve keys from the set according to the similarity between
 their stored vectors and a query vector that you specify.
 
 You can use vector sets to store any type of numeric vector but they are
 particularly optimized to work with text embedding vectors (see
-[Redis for AI]({{< relref "/develop/ai" >}}) to learn more about text
+[Redis for AI](../../ai/_index.md) to learn more about text
 embeddings). The example below shows how to use the
 [`sentence-transformers`](https://pypi.org/project/sentence-transformers/)
 library to generate vector embeddings and then
@@ -90,18 +90,18 @@ Use the
 method of `SentenceTransformer` to generate the
 embedding as an array of `float32` values. The `tobytes()` method converts
 the array to a byte string that you can pass to the
-[`vadd()`]({{< relref "/commands/vadd" >}}) command to set the embedding.
+[`vadd()`](../../../commands/vadd.md) command to set the embedding.
 Note that `vadd()` can also accept a list of `float` values to set the
 vector, but the byte string format is more compact and saves a little
 transmission time. If you later use
-[`vemb()`]({{< relref "/commands/vemb" >}}) to retrieve the embedding,
+[`vemb()`](../../../commands/vemb.md) to retrieve the embedding,
 it will return the vector as an array rather than the original byte
 string (note that this is different from the behavior of byte strings in
-[hash vector indexing]({{< relref "/develop/ai/search-and-query/vectors" >}})).
+[hash vector indexing](../../ai/search-and-query/vectors/_index.md)).
 
 The call to `vadd()` also adds the `born` and `died` values from the
 original dictionary as attribute data. You can access this during a query
-or by using the [`vgetattr()`]({{< relref "/commands/vgetattr" >}}) method.
+or by using the [`vgetattr()`](../../../commands/vgetattr.md) method.
 
 {{< clients-example set="home_vecsets" step="add_data" lang_filter="Python" description="Foundational: Add vector embeddings and attributes to a vector set using VADD command" difficulty="beginner" >}}
 {{< /clients-example >}}
@@ -111,7 +111,7 @@ or by using the [`vgetattr()`]({{< relref "/commands/vgetattr" >}}) method.
 You can now query the data in the set. The basic approach is to use the
 `encode()` method to generate another embedding vector for the query text.
 (This is the same method used to add the elements to the set.) Then, pass
-the query vector to [`vsim()`]({{< relref "/commands/vsim" >}}) to return elements
+the query vector to [`vsim()`](../../../commands/vsim.md) to return elements
 of the set, ranked in order of similarity to the query.
 
 Start with a simple query for "actors":
@@ -161,7 +161,7 @@ mathematicians. This seems reasonable given the connection between mathematics
 and science.
 
 You can also use
-[filter expressions]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+[filter expressions](../../data-types/vector-sets/filtered-search.md)
 with `vsim()` to restrict the search further. For example,
 repeat the "science" query, but this time limit the results to people
 who died before the year 2000:
@@ -178,16 +178,16 @@ elements that have already been filtered out of the search.
 
 ## More information
 
-See the [vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+See the [vector sets](../../data-types/vector-sets/_index.md)
 docs for more information and code examples. See the
-[Redis for AI]({{< relref "/develop/ai" >}}) section for more details
+[Redis for AI](../../ai/_index.md) section for more details
 about text embeddings and other AI techniques you can use with Redis.
 
 You may also be interested in
-[vector search]({{< relref "/develop/clients/redis-py/vecsearch" >}}).
+[vector search](vecsearch.md).
 This is a feature of
-[Redis Search]({{< relref "/develop/ai/search-and-query" >}})
+[Redis Search](../../ai/search-and-query/_index.md)
 that lets you retrieve
-[JSON]({{< relref "/develop/data-types/json" >}}) and
-[hash]({{< relref "/develop/data-types/hashes" >}}) documents based on
+[JSON](../../data-types/json/_index.md) and
+[hash](../../data-types/hashes.md) documents based on
 vector data stored in their fields.
diff --git a/content/operate/oss_and_stack/management/optimization/benchmarks/index.md b/content/operate/oss_and_stack/management/optimization/benchmarks/index.md
index 200bdfb95b..9969ffef73 100644
--- a/content/operate/oss_and_stack/management/optimization/benchmarks/index.md
+++ b/content/operate/oss_and_stack/management/optimization/benchmarks/index.md
@@ -126,7 +126,7 @@ specified with `-c`) sends the next command only when the reply of the previous
 command is received, this means that the server will likely need a read call
 in order to read each command from every client. Also RTT is paid as well.
 
-Redis supports [pipelining](/topics/pipelining), so it is possible to send
+Redis supports [pipelining](/develop/using-commands/pipelining), so it is possible to send
 multiple commands at once, a feature often exploited by real world applications.
 Redis pipelining is able to dramatically improve the number of operations per
 second a server is able to deliver.
diff --git a/content/operate/oss_and_stack/management/security/_index.md b/content/operate/oss_and_stack/management/security/_index.md
index 10c49147f0..4b1a4662ca 100644
--- a/content/operate/oss_and_stack/management/security/_index.md
+++ b/content/operate/oss_and_stack/management/security/_index.md
@@ -20,7 +20,7 @@ You can learn more about access control, data protection and encryption, secure
 
 For security-related contacts, open an issue on GitHub, or when you feel it
 is really important to preserve the security of the communication, use this
-[downloadable GPG key](/operate/oss_and_stack/management/security/gpgkey.txt).
+[downloadable GPG key](gpgkey.txt).
 
 ## Security model
 
diff --git a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md
index 2c1c664ebf..2c8afbb60c 100644
--- a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md
+++ b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md
@@ -250,7 +250,7 @@ Full details:
 
 - Major features
     - #[339](https://github.com/RedisGraph/RedisGraph/issues/339) Full Graph Response.  RedisGraph now allows to return Graph entities such as Nodes and Relationships.  This feature also enables graph visualisation.
-    - #[558](https://github.com/RedisGraph/RedisGraph/issues/558) Indexing functionality replaced by [RediSearch](redisearch.io). This results in support for
+    - #[558](https://github.com/RedisGraph/RedisGraph/issues/558) Indexing functionality replaced by [RediSearch](https://redisearch.io). This results in support for
         - compound indices
         - full text search
         - graph-aided search
diff --git a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisstack/redisstack-7.2-release-notes.md b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisstack/redisstack-7.2-release-notes.md
index 199e6bb0ae..8101027eea 100644
--- a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisstack/redisstack-7.2-release-notes.md
+++ b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisstack/redisstack-7.2-release-notes.md
@@ -889,7 +889,7 @@ JSON introduces two new commands:
 Graph capabilities are no longer included in Redis Stack. See the [RedisGraph End-of-Life Announcement](https://redis.com/blog/redisgraph-eol/).
 
 > [!WARNING]  
-If you are using graph capabilities with an older version of Redis Stack - please don't upgrade.
+> If you are using graph capabilities with an older version of Redis Stack - please don't upgrade.
 
 **Triggers and functions preview**:
 Triggers and functions is part of Redis Stack 7.2 as public preview, any feedback is highly appreciated.
diff --git a/content/operate/rs/7.22/references/rest-api/permissions.md b/content/operate/rs/7.22/references/rest-api/permissions.md
index 5f5d9adf94..050b125134 100644
--- a/content/operate/rs/7.22/references/rest-api/permissions.md
+++ b/content/operate/rs/7.22/references/rest-api/permissions.md
@@ -40,7 +40,7 @@ Available management roles include:
 | <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
-| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
+| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
  |
 
 ## Roles list per permission
diff --git a/content/operate/rs/7.8/references/rest-api/permissions.md b/content/operate/rs/7.8/references/rest-api/permissions.md
index 73556b0598..609b7a25c7 100644
--- a/content/operate/rs/7.8/references/rest-api/permissions.md
+++ b/content/operate/rs/7.8/references/rest-api/permissions.md
@@ -40,7 +40,7 @@ Available management roles include:
 | <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
-| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
+| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
  |
 
 ## Roles list per permission
diff --git a/content/operate/rs/8.0/flex/_index.md b/content/operate/rs/8.0/flex/_index.md
index a7211a9969..d6087b9a11 100644
--- a/content/operate/rs/8.0/flex/_index.md
+++ b/content/operate/rs/8.0/flex/_index.md
@@ -65,7 +65,7 @@ Flex does not replace long-term data persistence. For workloads that require dur
 
 ## Flex and Auto Tiering
 
-Flex replaces [Auto Tiering]({{< relref "/operate/rs/8.0/7.22/databases/auto-tiering" >}}) (formerly known as Redis on Flash). Redis Software selects the implementation based on your Redis version:
+Flex replaces [Auto Tiering]({{< relref "/operate/rs/7.22/databases/auto-tiering" >}}) (formerly known as Redis on Flash). Redis Software selects the implementation based on your Redis version:
 
 | Redis database version | Flex | Auto Tiering |
 |------------------------|------|--------------|
@@ -73,7 +73,7 @@ Flex replaces [Auto Tiering]({{< relref "/operate/rs/8.0/7.22/databases/auto-tie
 | 7.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span>|
 | 7.2 and earlier | <span title="Not supported">&#x274c;</span> | <span title="Supported">&#x2705;</span> |
 
-For Redis Software version 7.22.2-22 or earlier, see [Auto Tiering]({{< relref "/operate/rs/8.0/7.22/databases/auto-tiering" >}}).
+For Redis Software version 7.22.2-22 or earlier, see [Auto Tiering]({{< relref "/operate/rs/7.22/databases/auto-tiering" >}}).
 
 ### Differences between Flex and Auto Tiering
 
diff --git a/content/operate/rs/8.0/references/rest-api/permissions.md b/content/operate/rs/8.0/references/rest-api/permissions.md
index 52eb9609f5..36dd8410ab 100644
--- a/content/operate/rs/8.0/references/rest-api/permissions.md
+++ b/content/operate/rs/8.0/references/rest-api/permissions.md
@@ -40,7 +40,7 @@ Available management roles include:
 | <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_metrics](#view_all_metrics), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [upgrade_crdb](#upgrade_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
-| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
+| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
  |
 
 ## Roles list per permission
diff --git a/content/operate/rs/references/rest-api/permissions.md b/content/operate/rs/references/rest-api/permissions.md
index 35ba0a29f5..2210a1c4d1 100644
--- a/content/operate/rs/references/rest-api/permissions.md
+++ b/content/operate/rs/references/rest-api/permissions.md
@@ -39,7 +39,7 @@ Available management roles include:
 | <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_metrics](#view_all_metrics), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [upgrade_crdb](#upgrade_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
 | <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
-| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
+| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_sso](#view_sso), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
  |
 
 ## Roles list per permission
diff --git a/layouts/_default/_markup/render-blockquote.html b/layouts/_default/_markup/render-blockquote.html
new file mode 100644
index 0000000000..82e784232b
--- /dev/null
+++ b/layouts/_default/_markup/render-blockquote.html
@@ -0,0 +1,32 @@
+{{- /*
+  Blockquote render hook.
+
+  GitHub-style alert blockquotes (`> [!NOTE]`, `> [!WARNING]`, `> [!TIP]`,
+  `> [!INFO]`, `> [!IMPORTANT]`, `> [!CAUTION]`, …) render with the same styling
+  as the note/warning/tip/info/alert shortcodes (see
+  layouts/partials/components/alert.html), so callouts can be authored as
+  portable Markdown instead of shortcodes.
+
+  Because the alert body is native Markdown, `.Text` is rendered in the page's
+  context — links inside a callout resolve correctly (unlike the shortcodes,
+  which markdownify their inner content in a page-less context).
+
+  Regular blockquotes keep Hugo's default rendering.
+
+  Prototype from DOC-6909 (investigate alternatives to Hugo shortcodes).
+*/ -}}
+{{- if eq .Type "alert" -}}
+  {{- $title := or .AlertTitle (title .AlertType) -}}
+  <div class="alert p-3 relative flex flex-row flex-wrap items-center text-base bg-redis-pencil-200 rounded-md">
+    <div class="p-2 pr-5">{{ partial "icons/alert-circle.html" }}</div>
+    <div class="p-1 pl-4 sm:pl-6 border-l border-l-redis-ink-900 border-opacity-50 flex-1">
+    {{ with $title }}
+    <div class="font-medium">{{ . | safeHTML }}:</div>
+    {{ end }}
+    {{- .Text -}}
+    </div>
+  </div>
+{{- else -}}
+<blockquote>
+{{ .Text }}</blockquote>
+{{ end -}}
diff --git a/layouts/_default/_markup/render-link.html b/layouts/_default/_markup/render-link.html
new file mode 100644
index 0000000000..3788cfbee6
--- /dev/null
+++ b/layouts/_default/_markup/render-link.html
@@ -0,0 +1,64 @@
+{{- /*
+  Link render hook: resolves internal Markdown links to their published
+  permalink, recreating the behaviour of the `relref` shortcode so that
+  `[text](/path)` can replace `[text]({{< relref "/path" >}})`.
+
+  Prototype from DOC-6909 (investigate alternatives to Hugo shortcodes).
+  Verified against a `relref` baseline: internal links render byte-identically;
+  pre-existing plain links are normalised (relative -> absolute, `.md` stripped,
+  trailing slash added). See HUGO_DEPENDENCY_ASSESSMENT.md.
+
+  Resolution uses .PageInner, not .Page, so relative links resolve against the
+  page whose Markdown contains the link even when content is transcluded.
+
+  NOTE: remove the placeholder transition guard once every `relref` has been
+  migrated to a plain Markdown link.
+*/ -}}
+{{- $dest := .Destination -}}
+{{- $text := .Text -}}
+{{- $title := .Title -}}
+{{- if strings.Contains $dest "HAHAHUGOSHORTCODE" -}}
+  {{- /* A relref/shortcode has not been substituted yet; leave the placeholder
+         for Hugo to fill in and do not attempt to resolve or warn. */ -}}
+  <a href="{{ $dest | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+{{- else if strings.HasPrefix $dest "#" -}}
+  {{- /* Fragment-only: a same-page internal link, emitted unchanged. */ -}}
+  <a href="{{ $dest | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+{{- else if or (findRE "^[a-zA-Z][a-zA-Z0-9+.\\-]*:" $dest) (strings.HasPrefix $dest "//") -}}
+  {{- /* External: a URL scheme or protocol-relative link. Detected with findRE
+         rather than urls.Parse, which hard-errors on malformed destinations. */ -}}
+  <a href="{{ $dest | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+{{- else -}}
+  {{- $path := $dest -}}
+  {{- $anchor := "" -}}
+  {{- /* Split on the first `#` only, so an anchor that itself contains `#`
+         (malformed but present in the corpus) is preserved intact. */ -}}
+  {{- if strings.Contains $path "#" -}}
+    {{- $parts := split $path "#" -}}
+    {{- $path = index $parts 0 -}}
+    {{- $anchor = printf "#%s" (delimit (after 1 $parts) "#") -}}
+  {{- end -}}
+  {{- /* Strip a leading `./` so explicit same-directory links resolve; leave
+         `../` alone, which GetPage resolves relative to the current page. */ -}}
+  {{- $path = strings.TrimPrefix "./" $path -}}
+  {{- /* Normalise source-relative Markdown links so they resolve in the repo
+         (VS Code, GitHub) and here: drop the `.md`, and a trailing `/_index`
+         or `/index` from links that point at a section or leaf-bundle file. */ -}}
+  {{- $lookup := strings.TrimSuffix ".md" $path -}}
+  {{- $lookup = strings.TrimSuffix "/_index" $lookup -}}
+  {{- $lookup = strings.TrimSuffix "/index" $lookup -}}
+  {{- $target := .PageInner.GetPage $lookup -}}
+  {{- if $target -}}
+    <a href="{{ printf "%s%s" $target.RelPermalink $anchor | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+  {{- else -}}
+    {{- /* Not a content page: try a page-bundle resource (e.g. the source
+           files linked with [source](cache.rs) in the use-case demos). */ -}}
+    {{- $res := .PageInner.Resources.GetMatch $path -}}
+    {{- if $res -}}
+      <a href="{{ printf "%s%s" $res.RelPermalink $anchor | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+    {{- else -}}
+      {{- warnf "render-link: unresolved link %q on page %q" $dest .PageInner.Path -}}
+      <a href="{{ $dest | safeURL }}"{{ with $title }} title="{{ . }}"{{ end }}>{{ $text | safeHTML }}</a>
+    {{- end -}}
+  {{- end -}}
+{{- end -}}