correct links

Author: raphael-istari

README.md

@@ -167,4 +167,56 @@ Edit `themes/hugo-docs/layouts/partials/sidebar.html` and add:
 {{ if eq $menuType "yourtype" }}
   {{ $menu = .Site.Menus.yourtype }}
 {{ end }}
+```
+
+## Multi-Version Documentation
+
+This repository uses a build script to generate documentation for multiple versions from different Git branches.
+
+
+```bash
+./scripts/build.sh
+```
+
+This builds:
+- **Latest docs** from `main` branch → `/`
+- **Version docs** from release branches → `/v24.1/`, etc.
+
+## How It Works
+
+1. **Build Script** (`build.sh`) uses Git worktrees to temporarily check out each release branch
+2. **Hugo builds** each version into its own subdirectory with the appropriate base URL
+3. **Version selector** loads available versions from `versions.json` and displays a dropdown
+
+## Configuration
+
+Edit `build.sh` to add/remove versions:
+```bash
+VERSION_BRANCHES=("main" "release/v24.1")
+```
+
+```bash
+VERSION_BRANCHES=("release/v25.0" "release/v24.1")
+```
+
+## File Structure
+
+```
+layouts/partials/
+  └── version-selector.html    # Dropdown component
+scripts/
+  └── build.sh         # Build script
+public/                         # Generated output
+  ├── index.html               # Latest docs (main)
+  ├── versions.json            # Version metadata
+  ├── v24.1/                   # Version 24.1 docs
+  └── v24.2/                   # Version 24.2 docs
+```
+
+### Version Selector
+
+In  layout 
+
+```html
+{{ partial "version-selector.html" . }}
 ```

content/cli/decrypt.md

@@ -11,9 +11,8 @@ You might need to decrypt data from an encrypted Dgraph cluster for a variety of
 * Migration of data from an encrypted cluster to a non-encrypted cluster
 * Changing your data or schema by directly editing an RDF file or schema file
 
-To support these scenarios, Dgraph includes a `decrypt` command that decrypts encrypted RDF and schema files. To learn how to export RDF
-and schema files from Dgraph, see:
-[Dgraph Administration: Export database](/deploy/admin/dgraph-administration/#export-database).
+To support these scenarios, Dgraph includes a `decrypt` command that decrypts encrypted RDF and schema files. To learn how to export RDF and schema files from Dgraph, see:
+[Dgraph Administration: Export database]({{< relref "export-data">}}).
 
 The `decrypt` command supports a variety of symmetric key lengths, which
 determine the AES cypher used for encryption and decryption, as follows:

content/dgraph-overview.md

@@ -52,7 +52,7 @@ Dgraph is built from the ground up as a distributed system. Data is automaticall
 
 Each Dgraph cluster consists of multiple server groups (shards) that work together to store and query your data. Queries are automatically distributed across the relevant shards and results are aggregated, making the distributed nature transparent to your application. This architecture provides both horizontal scalability and high availability.
 
-For detailed information about Dgraph's distributed architecture, clustering, and replication, see the [Architecture documentation](/deploy/dgraph-architecture).
+For detailed information about Dgraph's distributed architecture, clustering, and replication, see the [Architecture documentation]({{< relref "dgraph-architecture">}}).
 
 ## Enterprise-Grade Features
 

content/graphql-dql/graphql-data-loading.md

@@ -12,11 +12,11 @@ type = "graphql"
 
 After you have deployed your first GraphQL Schema, you get a GraphQL API served on ``/graphql`` endpoint and an empty backend. You can populate the graph database using the mutations operations on the GraphQL API.
 
-A more efficient way to populate the database is to use the Dgraph's [import tools](/howto/importdata/).
+A more efficient way to populate the database is to use the Dgraph's [import tools]({{< relref "import-data">}}).
 
 The first step is to understand the [schema mapping]({{<relref "graphql-dql-schema">}}) and to prepare your RDF files or JSON files to follow the internal Dgraph predicates names. 
 You also have to make sure that you properly generate data for the `dgraph.type` predicate so that each node is asscociated with it's type.
 
-If you are using the [initial import](/howto/importdata/bulk-loader/) tool, you can provide the GraphQL schema along with the data to import when executing the bulk load.
+If you are using the [initial import]({{< relref "bulk-loader">}}) tool, you can provide the GraphQL schema along with the data to import when executing the bulk load.
 
-If you are using the [live import](/howto/importdata/live-loader/) tool, you must first deploy your GraphQL Schema and then proceed with the import. Deploying the schema first, will generate the predicates indexes and reduce the loading time.
+If you are using the [live import]({{< relref "live-loader">}}) tool, you must first deploy your GraphQL Schema and then proceed with the import. Deploying the schema first, will generate the predicates indexes and reduce the loading time.

content/graphql-dql/graphql-dql-schema.md

@@ -41,7 +41,7 @@ The API and the engine logic are generated from the schema defining the types of
 
 ### In DQL, the schema described the predicates
 
-Dgraph maintains a list of all predicates names with their type and indexes in the [Dgraph types schema](/dql/dql-schema/).
+Dgraph maintains a list of all predicates names with their type and indexes in the [Dgraph types schema]({{< relref "dql-schema">}}).
 
 
 ### Schema mapping
@@ -159,7 +159,7 @@ type Property {
 The fact that the GraphQL API backend is a graph in Dgraph, implies that you can use Dgraph DQL on the data that is also served by the GraphQL API operations.
 
 In particular, you can 
-- use Dgraph DQL mutations but also Dgraph's [import tools](/howto/importdata/) to populate the graph after you have deployed a GraphQL Schema. See [GraphQL data loading]({{<relref "graphql-data-loading.md">}})
+- use Dgraph DQL mutations but also Dgraph's [import tools]({{< relref "import-data">}}) to populate the graph after you have deployed a GraphQL Schema. See [GraphQL data loading]({{<relref "graphql-data-loading.md">}})
 - use DQL to query the graph in the context of authorization rules and custom resolvers.
 - add knowledge to your graph such as meta-data, score, annotations, ...,  but also relationships or relationships attributes (facets) that could be the result of similarity computation, threat detection a.s.o. The added data could be hidden from your GraphQL API clients but be available to logic written with DQL clients.
 - break things using DQL: DQL is powerful and is bypassing constraints expressed in the GraphQL schema. You can for example delete a node predicate that is mandatory in the GraphQL API! Hopefully there are ways to secure who can read/write/delete predicates. ( see the [ACL](/enterprise-features/access-control-lists/)) section.