diff --git a/pages/database-management/authentication-and-authorization.mdx b/pages/database-management/authentication-and-authorization.mdx
index 9fb2be18e..8f16579b7 100644
--- a/pages/database-management/authentication-and-authorization.mdx
+++ b/pages/database-management/authentication-and-authorization.mdx
@@ -17,6 +17,10 @@ Learn how to manage users in Memgraph.
 
 Learn how to manage roles, set up their privileges and fine-grained access control. 
 
+## [Multiple roles per user and multi-tenant roles](/database-management/authentication-and-authorization/multiple-roles) (Enterprise)
+
+Learn how to assign multiple roles to users simultaneously and understand how permissions are combined from all roles.
+
 ## [Auth system integrations](/database-management/authentication-and-authorization/auth-system-integrations) (Enterprise)
 
 Learn how to integrate with third-party auth systems and manage user
diff --git a/pages/database-management/authentication-and-authorization/_meta.ts b/pages/database-management/authentication-and-authorization/_meta.ts
index 52e2d13d8..43eade6cb 100644
--- a/pages/database-management/authentication-and-authorization/_meta.ts
+++ b/pages/database-management/authentication-and-authorization/_meta.ts
@@ -1,6 +1,7 @@
 export default {
     "users": "Users",
     "role-based-access-control": "Role-based access control",
+    "multiple-roles": "Multiple roles per user and multi-tenant roles",
     "auth-system-integrations": "Auth system integrations",
     "impersonate-user": "Impersonate user"
 }
diff --git a/pages/database-management/authentication-and-authorization/auth-system-integrations.mdx b/pages/database-management/authentication-and-authorization/auth-system-integrations.mdx
index f5cd5e6c7..73b19c255 100644
--- a/pages/database-management/authentication-and-authorization/auth-system-integrations.mdx
+++ b/pages/database-management/authentication-and-authorization/auth-system-integrations.mdx
@@ -27,7 +27,7 @@ privileges will still apply but you won't be able to manage them.
 ### Roles
 
 User roles must be defined in Memgraph before using auth modules because these
-modules return the role associated with the user.
+modules return the role(s) associated with the user. Memgraph now supports multiple roles per user, allowing auth modules to return either a single role or multiple roles.
 
 ### Flags
 
@@ -85,8 +85,9 @@ The protocol used between Memgraph and the module is as follows:
  - Auth responses must be objects that contain the following fields:
     - `authenticated` - a `bool` indicating whether the user is allowed to log
      in to the database
-    - `role` - a `string` indicating which role the user should have (must be
-     supplied)
+    - `role` - a `string` indicating which role the user should have (backward compatible)
+    - `roles` - an array of strings indicating which roles the user should have (new format)
+    - `username` - the user's username (optional)
     - `errors` (optional) - if `authenticated` is false, Memgraph will put up a
      warning with the error message returned by the module
 
@@ -95,6 +96,53 @@ Memgraph won't allow the user to log in to the database and will automatically
 restart the auth module for the next auth request. All crash logs will be seen
 in Memgraph's output (typically in `systemd` logs using `journalctl`).
 
+### Multiple roles support
+
+Memgraph now supports multiple roles per user in auth module responses. Auth modules can return either a single role (backward compatible) or multiple roles (new format).
+
+#### Single role response (backward compatible)
+
+```python
+def authenticate(username, password):
+    return {
+        "authenticated": True,
+        "role": "moderator"  # Single role as string
+    }
+```
+
+#### Multiple roles response (new format)
+
+```python
+def authenticate(username, password):
+    return {
+        "authenticated": True,
+        "roles": ["admin", "user"]  # Multiple roles as array
+    }
+```
+
+#### Single role in array format
+
+```python
+def authenticate(username, password):
+    return {
+        "authenticated": True,
+        "roles": ["admin"]  # Single role in array
+    }
+```
+
+The system will:
+1. First check for a `roles` field in the response
+2. If `roles` is an array, use all roles in the array
+3. If `roles` is a string, use it as a single role
+4. If no `roles` field is found, fall back to the `role` field for backward compatibility
+5. If no valid roles are found, authentication fails
+
+When a user has multiple roles, their permissions are combined using the following rules:
+- **Grants**: If any role grants a permission, the user has that permission
+- **Denies**: If any role denies a permission, the user is denied that permission
+- **Database Access**: If any role grants and no role denies access to a database, the user has access
+- **Fine-grained Permissions**: Combined using the same grant/deny logic
+
 ### Module example
 
 This very simple example auth module is written in Python, but any programming
@@ -107,7 +155,15 @@ import io
 
 
 def authenticate(username, password):
-    return {"authenticated": True, "role": "moderator"}
+    # Example with multiple roles
+    if username == "admin_user" and password == "password":
+        return {"authenticated": True, "roles": ["admin", "user"]}
+    
+    # Example with single role (backward compatible)
+    if username == "moderator_user" and password == "password":
+        return {"authenticated": True, "role": "moderator"}
+    
+    return {"authenticated": False, "errors": "Invalid credentials"}
 
 
 if __name__ == "__main__":
@@ -132,8 +188,8 @@ files. For example:
 #!/usr/bin/python3
 import module
 
-assert module.authenticate("sponge", "bob") == {"authenticated": True, "role": "analyst"}
-assert module.authenticate("CHUCK", "NORRIS") == {"authenticated": True, "role": "admin"}
+assert module.authenticate("admin_user", "password") == {"authenticated": True, "roles": ["admin", "user"]}
+assert module.authenticate("moderator_user", "password") == {"authenticated": True, "role": "moderator"}
 ```
 
 ## Single sign-on
@@ -163,6 +219,10 @@ created in the Memgraph DB beforehand. Additionally, you have to grant [label-ba
 
 </Callout>
 
+<Callout type="info">
+SSO identity providers often return multiple roles for users. Memgraph now supports this natively - if your identity provider returns multiple roles, they will all be mapped to Memgraph roles and the user will have permissions from all assigned roles combined.
+</Callout>
+
 ### SAML
 
 Memgraph has built-in support for single sign-on (SSO) over the SAML protocol
diff --git a/pages/database-management/authentication-and-authorization/multiple-roles.mdx b/pages/database-management/authentication-and-authorization/multiple-roles.mdx
new file mode 100644
index 000000000..f32e3a18f
--- /dev/null
+++ b/pages/database-management/authentication-and-authorization/multiple-roles.mdx
@@ -0,0 +1,289 @@
+---
+title: Multiple roles per user and multi-tenant roles
+description: Learn how to assign database-specific roles to users in multi-tenant environments with special permission filtering logic.
+---
+
+import { Callout } from 'nextra/components'
+
+# Multi-tenant roles (Enterprise)
+
+Memgraph Enterprise supports multi-tenant roles, which allow users to have different roles assigned to them for specific databases. This feature enables proper tenant isolation and fine-grained access control in multi-tenant environments.
+
+## Overview
+
+Multi-tenant roles are a specialized form of multiple roles that include special logic for database-specific permission filtering. When a user has multi-tenant roles, their permissions are dynamically filtered based on which database they're accessing, ensuring proper tenant isolation.
+
+Key benefits:
+- **Tenant Isolation**: Users can have different permissions for different databases
+- **SSO Integration**: Support for external identity providers that return multiple roles
+
+## Database access with users and roles
+
+### Basic database access
+
+In Memgraph Enterprise, both users and roles can have database access permissions:
+
+```cypher
+-- Grant database access to a role
+GRANT DATABASE db_name TO user_or_role;
+
+-- Deny database access
+DENY DATABASE db_name TO user_or_role;
+
+-- Revoke database access
+REVOKE DATABASE db_name TO user_or_role;
+```
+
+### How database access works
+
+Database access follows these rules:
+- **Grants**: If any role or user grants access to a database, database is granted
+- **Denies**: If any role or user denies access to a database, database is denied
+- **Access**: User or role has database access if it is granted and not denied
+
+## Database access with multiple roles
+
+### Combining database access
+
+When a user has multiple roles, their database access is combined from all roles:
+
+```cypher
+-- Create roles with different database access
+CREATE ROLE role1;
+CREATE ROLE role2;
+
+-- Grant different database access to each role
+GRANT DATABASE db1 TO role1;
+GRANT DATABASE db2 TO role2;
+
+-- Create user and assign both roles
+CREATE USER alice IDENTIFIED BY 'password';
+SET ROLE FOR alice TO role1, role2;
+
+-- Result: Alice has access to both db1 and db2
+```
+
+### Database access conflicts
+
+When roles have conflicting database access, deny takes precedence:
+
+```cypher
+-- Role1 grants access to db1
+GRANT DATABASE db1 TO role1;
+
+-- Role2 denies access to db1
+DENY DATABASE db1 TO role2;
+
+-- User with both roles
+SET ROLE FOR user TO role1, role2;
+
+-- Result: User is denied access to db1 (deny takes precedence)
+```
+
+## Privileges with multiple roles
+
+When a user has multiple roles, their privileges are combined according to the following rules:
+
+- **Grant**: If any assigned role with access to the database grants a privilege, the user is granted that privilege.
+- **Deny**: If any assigned role with access to the database denies a privilege, the user is denied that privilege—even if another role grants it.
+- **Effective privilege**: The user's effective privileges are the union of all granted privileges, minus any that are denied by any role.
+
+This means that **deny always takes precedence over grant** when there is a conflict.
+**Note:** The resulting user privileges contain user's privileges only if the user also has access to the database.
+
+## Creating database-specific roles
+
+### Using database access for tenant isolation
+
+You can create roles that are specific to certain databases by controlling their database access:
+
+```cypher
+-- Create tenant-specific roles
+CREATE ROLE tenant1_admin;
+CREATE ROLE tenant2_user;
+
+-- Grant database access to specific tenants
+GRANT DATABASE tenant1_db TO tenant1_admin;
+GRANT DATABASE tenant2_db TO tenant2_user;
+
+-- Grant appropriate permissions
+GRANT ALL PRIVILEGES TO tenant1_admin;
+GRANT MATCH, CREATE, MERGE, SET TO tenant2_user;
+
+-- Create user with both roles
+CREATE USER bob IDENTIFIED BY 'password';
+SET ROLE FOR bob TO tenant1_admin, tenant2_user;
+```
+
+### Limitations of this approach
+
+While this approach works, it has some limitations:
+- Users get access to all databases their roles have access to
+- No fine-grained control over which role applies to which database
+- Permission filtering is based on database access, not role assignment
+- Admin needs to create a set of role for each database
+
+## Better API: Database-specific role assignment
+
+### Setting roles ON a database
+
+Memgraph Enterprise provides a better API for database-specific role assignment using the `ON database` clause:
+
+```cypher
+-- Assign role to specific database
+SET ROLE FOR user_name TO role_name ON database_name;
+
+-- Remove role from specific database
+CLEAR ROLE FOR user_name ON database_name;
+
+-- Remove all roles
+CLEAR ROLES;
+```
+
+**Note:** Multiple roles can be specified on a database. However, the list of roles needs to be exhaustive.
+
+### How it works
+
+This API provides true database-specific role assignment:
+
+```cypher
+-- Create roles with database access
+CREATE ROLE tenant1_admin;
+CREATE ROLE tenant2_user;
+
+-- Grant database access to roles
+GRANT DATABASE tenant1_db TO tenant1_admin;
+GRANT DATABASE tenant2_db TO tenant2_user;
+
+-- Grant permissions
+GRANT ALL PRIVILEGES TO tenant1_admin;
+GRANT MATCH, CREATE, MERGE, SET TO tenant2_user;
+
+-- Create user with database-specific roles
+CREATE USER alice IDENTIFIED BY 'password';
+SET ROLE FOR alice TO tenant1_admin ON tenant1_db;
+SET ROLE FOR alice TO tenant2_user ON tenant2_db;
+```
+
+**Note:** The list of roles defined in the SET ROLE query is an exhaustive list.
+
+### Special logic for database filtering
+
+When using `SET ROLE ... ON database`, the system applies special logic:
+
+1. **Database Access Check**: Only roles with access to the specified database can be assigned
+2. **Permission Filtering**: When accessing a database, only roles assigned to that database are considered
+3. **Isolation**: Users cannot access permissions from roles assigned to other databases
+4. **Automatic Filtering**: The system automatically filters permissions based on the current database context
+
+## Multi-tenant role management
+
+### Adding database-specific roles
+
+To assign a role to a user for a specific database:
+
+```cypher
+-- The role must have access to the database
+GRANT DATABASE database_name TO role_name;
+SET ROLE FOR user_name TO role_name ON database_name;
+```
+
+### Clearing database-specific roles
+
+To remove a role from a specific database:
+
+```cypher
+CLEAR ROLE FOR user_name ON database_name;
+```
+
+### Viewing multi-tenant roles
+
+To see which roles a user has for a specific database:
+
+```cypher
+SHOW ROLES FOR user_name ON database_name;
+```
+
+### Viewing permissions for a specific database
+
+To see what permissions a user has in a specific database:
+
+```cypher
+SHOW PRIVILEGES FOR user_name ON database_name;
+```
+
+
+### SSO integration with multi-tenant roles
+
+When using external auth modules, users can be assigned multi-tenant roles based on their identity provider roles:
+
+```python
+def authenticate(username, password):
+    # Example: User has multiple roles from identity provider
+    if username == "cross_tenant_manager" and password == "password":
+        return {
+            "authenticated": True,
+            "roles": ["tenant1_admin", "tenant2_user"],
+            "role_databases": ["tenant1_db", "tenant2_db"],
+            "username": "cross_tenant_manager"
+        }
+    
+    return {"authenticated": False, "errors": "Invalid credentials"}
+```
+
+## Database access control
+
+### Main database selection
+
+When a user has multi-tenant roles with access to different databases, the system determines the main database:
+
+```cypher
+-- Create roles with different main databases
+CREATE ROLE role1;
+CREATE ROLE role2;
+GRANT DATABASE db1 TO role1;
+GRANT DATABASE db2 TO role2;
+SET MAIN DATABASE db1 FOR role1;
+SET MAIN DATABASE db2 FOR role2;
+
+-- User with both roles
+CREATE USER user1 IDENTIFIED BY 'password';
+SET ROLE role1 FOR user1 ON db1;
+SET ROLE role2 FOR user1 ON db2;
+
+```
+
+<Callout type="info">
+In case of an SSO connection, no user information is stored in Memgraph; instead the auth module returns roles associated with the connection. 
+In this case, there are no guarantees which role's main database will be selected. Use "database" in the session arguments to define the target database.
+</Callout>
+
+### Database-specific permission filtering
+
+The special logic ensures that when accessing a specific database, only roles assigned to that database are considered:
+
+```cypher
+-- Role with access to multiple databases
+CREATE ROLE multi_db_role;
+GRANT DATABASE db1 TO multi_db_role;
+GRANT DATABASE db2 TO multi_db_role;
+GRANT MATCH, CREATE ON db1 TO multi_db_role;
+GRANT MATCH ON db2 TO multi_db_role;
+
+-- User with this role
+CREATE USER user1 IDENTIFIED BY 'password';
+SET ROLE multi_db_role FOR user1 ON db1;
+SET ROLE multi_db_role FOR user1 ON db2;
+
+-- When accessing db1: has MATCH, CREATE
+-- When accessing db2: has only MATCH
+```
+
+## Best practices for multi-tenant environments
+
+1. **Use descriptive role names**: Include tenant information in role names (e.g., `tenant1_admin`, `tenant2_user`)
+2. **Follow principle of least privilege**: Grant only necessary permissions to each role
+3. **Separate tenant-specific roles**: Create distinct roles for each tenant to ensure proper isolation
+4. **Test permission combinations**: Verify that multi-tenant permissions work correctly in each database
+5. **Document role assignments**: Keep track of which users have which roles for which databases
+6. **Use deny sparingly**: Remember that deny takes precedence over grant across all databases
diff --git a/pages/database-management/authentication-and-authorization/role-based-access-control.mdx b/pages/database-management/authentication-and-authorization/role-based-access-control.mdx
index 7f1f93b87..71cc02cc8 100644
--- a/pages/database-management/authentication-and-authorization/role-based-access-control.mdx
+++ b/pages/database-management/authentication-and-authorization/role-based-access-control.mdx
@@ -20,9 +20,13 @@ privileges to roles, but for even more control over who can access certain
 data, Memgraph Enterprise offers [fine-grained access
 control](#fine-grained-access-control). 
 
+<Callout type="info">
+[Multiple roles per user and multi-tenant roles](/database-management/authentication-and-authorization/multiple-roles) for more information regarding assigning multiple roles to users or assigning roles for a specific database.
+</Callout>
+
 ## User roles 
 
-Each user can be assigned at most one user role. User roles are abstractions
+Users can be assigned multiple roles simultaneously, with permissions from all roles being combined. User roles are abstractions
 that capture the privilege levels of a set of users. 
 
 For example, suppose that `Dominik` and `Marko` belong to the upper management of a
@@ -37,6 +41,12 @@ to that user). Similarly, each privilege that is denied to a user role is
 automatically denied to all users with that role (even if it has been
 explicitly granted to that user).
 
+When a user has multiple roles, their permissions are combined using the following rules:
+- **Grants**: If any role grants a permission, the user has that permission
+- **Denies**: If any role denies a permission, the user is denied that permission
+- **Database Access**: If any role grants access to a database, the user has access
+- **Fine-grained Permissions**: Combined using the same grant/deny logic
+
 To create a user role, run the following query:
 
 ```cypher
@@ -48,10 +58,10 @@ If a role already exists, you can use `IF NOT EXISTS` to only create new roles.
 To assign a user with a certain user role, run the following query:
 
 ```cypher
-SET ROLE FOR user_name TO role_name;
+SET ROLE FOR user_name TO role_name [, another_role, ...];
 ```
 
-To remove the role from the user, run the following query:
+To remove all roles from the user, run the following query:
 
 ```cypher
 CLEAR ROLE FOR user_name;
@@ -63,12 +73,14 @@ To show all users with a certain role:
 SHOW USERS FOR role_name;
 ```
 
-To show what role a user has, run the following query:
+To show what roles a user has, run the following query:
 
 ```cypher
 SHOW ROLE FOR user_name;
 ```
 
+TODO: multi-tenant environment show role for user_name 
+
 To list all defined user roles run:
 
 ```cypher
diff --git a/pages/database-management/authentication-and-authorization/users.mdx b/pages/database-management/authentication-and-authorization/users.mdx
index 41b8393ec..67576102c 100644
--- a/pages/database-management/authentication-and-authorization/users.mdx
+++ b/pages/database-management/authentication-and-authorization/users.mdx
@@ -15,6 +15,10 @@ out [role-based access
 control](/database-management/authentication-and-authorization/role-based-access-control)
 and [auth system integrations](/database-management/authentication-and-authorization/auth-system-integrations).
 
+<Callout type="info">
+Memgraph Enterprise now supports database-specific roles for a user, allowing users to have different roles on specific databases. See the [role-based access control](/database-management/authentication-and-authorization/role-based-access-control) section for details on managing multiple roles.
+</Callout>
+
 ## Administer users
 
 Creating a user can be done by executing the following command:
diff --git a/pages/getting-started/install-memgraph/direct-download-links.mdx b/pages/getting-started/install-memgraph/direct-download-links.mdx
index 81f13463e..931afa3ce 100644
--- a/pages/getting-started/install-memgraph/direct-download-links.mdx
+++ b/pages/getting-started/install-memgraph/direct-download-links.mdx
@@ -11,33 +11,32 @@ Download Hub](https://memgraph.com/download/). If you need direct links for the
 latest version of Memgraph database, take a look at the list below.
 
 ## Docker
-- [https://download.memgraph.com/memgraph/v3.3.0/docker/memgraph-3.3.0-docker.tar.gz](https://download.memgraph.com/memgraph/v3.3.0/docker/memgraph-3.3.0-docker.tar.gz)
-- [https://download.memgraph.com/memgraph/v3.3.0/docker-aarch64/memgraph-3.3.0-docker.tar.gz](https://download.memgraph.com/memgraph/v3.3.0/docker-aarch64/memgraph-3.3.0-docker.tar.gz)
-- [https://download.memgraph.com/memgraph/v3.3.0/docker-relwithdebinfo/memgraph-3.3.0-relwithdebinfo-docker.tar.gz](https://download.memgraph.com/memgraph/v3.3.0/docker-relwithdebinfo/memgraph-3.3.0-relwithdebinfo-docker.tar.gz)
-- [https://download.memgraph.com/memgraph/v3.3.0/docker-aarch64-relwithdebinfo/memgraph-3.3.0-relwithdebinfo-docker.tar.gz](https://download.memgraph.com/memgraph/v3.3.0/docker-aarch64-relwithdebinfo/memgraph-3.3.0-relwithdebinfo-docker.tar.gz)
+- [https://download.memgraph.com/memgraph/v3.4.0/docker/memgraph-3.4.0-docker.tar.gz](https://download.memgraph.com/memgraph/v3.4.0/docker/memgraph-3.4.0-docker.tar.gz)
+- [https://download.memgraph.com/memgraph/v3.4.0/docker-aarch64/memgraph-3.4.0-docker.tar.gz](https://download.memgraph.com/memgraph/v3.4.0/docker-aarch64/memgraph-3.4.0-docker.tar.gz)
+- [https://download.memgraph.com/memgraph/v3.4.0/docker-relwithdebinfo/memgraph-3.4.0-relwithdebinfo-docker.tar.gz](https://download.memgraph.com/memgraph/v3.4.0/docker-relwithdebinfo/memgraph-3.4.0-relwithdebinfo-docker.tar.gz)
+- [https://download.memgraph.com/memgraph/v3.4.0/docker-aarch64-relwithdebinfo/memgraph-3.4.0-relwithdebinfo-docker.tar.gz](https://download.memgraph.com/memgraph/v3.4.0/docker-aarch64-relwithdebinfo/memgraph-3.4.0-relwithdebinfo-docker.tar.gz)
 
 ## Linux
 
 Memgraph can be run on the Linux distributions listed below.
 
 ### CentOS
-- [https://download.memgraph.com/memgraph/v3.3.0/centos-9/memgraph-3.3.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.3.0/centos-9/memgraph-3.3.0_1-1.x86_64.rpm)
-- [https://download.memgraph.com/memgraph/v3.3.0/centos-10/memgraph-3.3.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.3.0/centos-10/memgraph-3.3.0_1-1.x86_64.rpm)
+- [https://download.memgraph.com/memgraph/v3.4.0/centos-9/memgraph-3.4.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.4.0/centos-9/memgraph-3.4.0_1-1.x86_64.rpm)
+- [https://download.memgraph.com/memgraph/v3.4.0/centos-10/memgraph-3.4.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.4.0/centos-10/memgraph-3.4.0_1-1.x86_64.rpm)
 
 ### Debian
-- [https://download.memgraph.com/memgraph/v3.3.0/debian-11/memgraph_3.3.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.3.0/debian-11/memgraph_3.3.0-1_amd64.deb)
-- [https://download.memgraph.com/memgraph/v3.3.0/debian-12/memgraph_3.3.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.3.0/debian-12/memgraph_3.3.0-1_amd64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/debian-11/memgraph_3.4.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.4.0/debian-11/memgraph_3.4.0-1_amd64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/debian-12/memgraph_3.4.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.4.0/debian-12/memgraph_3.4.0-1_amd64.deb)
 
 ### Fedora
-- [https://download.memgraph.com/memgraph/v3.3.0/fedora-41/memgraph-3.3.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.3.0/fedora-41/memgraph-3.3.0_1-1.x86_64.rpm)
+- [https://download.memgraph.com/memgraph/v3.4.0/fedora-41/memgraph-3.4.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.4.0/fedora-41/memgraph-3.4.0_1-1.x86_64.rpm)
 
 ### Red Hat
-- [https://download.memgraph.com/memgraph/v3.3.0/centos-9/memgraph-3.3.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.3.0/centos-9/memgraph-3.3.0_1-1.x86_64.rpm)
+- [https://download.memgraph.com/memgraph/v3.4.0/centos-9/memgraph-3.4.0_1-1.x86_64.rpm](https://download.memgraph.com/memgraph/v3.4.0/centos-9/memgraph-3.4.0_1-1.x86_64.rpm)
 
 ### Ubuntu
-- [https://download.memgraph.com/memgraph/v3.3.0/ubuntu-22.04/memgraph_3.3.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.3.0/ubuntu-22.04/memgraph_3.3.0-1_amd64.deb)
-- [https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04/memgraph_3.3.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04/memgraph_3.3.0-1_amd64.deb)
-- [https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-relwithdebinfo/memgraph_3.3.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-relwithdebinfo/memgraph_3.3.0-1_amd64.deb)
-- [https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-aarch64/memgraph_3.3.0-1_arm64.deb](https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-aarch64/memgraph_3.3.0-1_arm64.deb)
-- [https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-aarch64-relwithdebinfo/memgraph_3.3.0-1_arm64.deb](https://download.memgraph.com/memgraph/v3.3.0/ubuntu-24.04-aarch64-relwithdebinfo/memgraph_3.3.0-1_arm64.deb)
-
+- [https://download.memgraph.com/memgraph/v3.4.0/ubuntu-22.04/memgraph_3.4.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.4.0/ubuntu-22.04/memgraph_3.4.0-1_amd64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04/memgraph_3.4.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04/memgraph_3.4.0-1_amd64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-relwithdebinfo/memgraph_3.4.0-1_amd64.deb](https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-relwithdebinfo/memgraph_3.4.0-1_amd64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-aarch64/memgraph_3.4.0-1_arm64.deb](https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-aarch64/memgraph_3.4.0-1_arm64.deb)
+- [https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-aarch64-relwithdebinfo/memgraph_3.4.0-1_arm64.deb](https://download.memgraph.com/memgraph/v3.4.0/ubuntu-24.04-aarch64-relwithdebinfo/memgraph_3.4.0-1_arm64.deb)