Memgraph on Arm

Memgraph is an open-source, in-memory graph database built for real-time streaming and analytical workloads. It’s compatible with the Cypher query language and the Bolt protocol used by Neo4j drivers, so existing Cypher/Bolt applications can connect without changes.

Memgraph publishes native aarch64 Linux packages and multi-architecture Docker images, so it runs unmodified on Arm-based hardware.

Graph algorithms parallelize well and scale with core count. Arm server instances can offer a lower cost per query than equivalent x86 instances for memory-intensive graph workloads.

In this install guide, you’ll learn two installation paths:

• Docker: the quickest way to try Memgraph, and the portable option for macOS, Windows, and any Linux distribution.
• Native Linux packages: a good choice when Docker is unavailable or not preferred, or when you want to benchmark Memgraph directly on the host.

At the end of each path, you’ll run a few Cypher queries with mgconsole, then optionally add MAGE , Memgraph’s graph-algorithm and query-module extension library.

Before you begin

Confirm you are using an Arm computer with 64-bit Linux by running:

    

        
        
uname -m

    

The output is similar to:

    

        
        aarch64

        
    

If you see a different result, you aren’t using an Arm computer running 64-bit Linux.

Install Memgraph with Docker

You can use Docker to run Memgraph on any operating system. The official images on Docker Hub are multi-arch manifests, so docker pull automatically selects the arm64 variant on Arm hosts.

If you’ve not already installed Docker, follow the steps in the Docker install guide to do so.

Start the Memgraph container

The core image is memgraph/memgraph, which includes the Memgraph database plus the bundled mgconsole CLI. Start it with:

    

        
        
docker run -p 7687:7687 -p 7444:7444 --name memgraph memgraph/memgraph:3.10.1

    

The container exposes two ports:

• 7687: the Bolt port used by mgconsole, Memgraph Lab, and every Bolt-compatible driver.
• 7444: streams Memgraph logs to Memgraph Lab for real-time monitoring.

To confirm that the Arm image was pulled, inspect it:

    

        
        
docker inspect memgraph/memgraph:3.10.1 --format '{{.Architecture}}'

    

The output is similar to:

    

        
        arm64

        
    

Choose a Docker image

The following are Docker images that you can choose depending on the Memgraph features that you want to use:

Start with memgraph/memgraph to get the Memgraph database. If you later want PageRank, community detection, node embeddings, NetworkX integration, or other advanced query modules, see the MAGE section .

Connect with mgconsole inside the container

The memgraph/memgraph:3.10.1 image ships with mgconsole already inside the container. Run mgconsole in the container:

    

        
        
docker exec -it memgraph mgconsole

    

The output is similar to:

    

        
        mgconsole 1.5.2
Connected to 'memgraph://127.0.0.1:7687'
Type :help for shell usage
Quit the shell by typing Ctrl-D(eof) or :quit
memgraph>

        
    

For example mgconsole queries, see the example queries section.

Install Memgraph natively on Linux

Memgraph provides native aarch64 packages for the following distributions:

• Ubuntu 24.04
• Debian 12 and Debian 13
• Fedora 42

Choose the package that matches your distribution from the Memgraph Download Hub . For convenience, you can find direct download URLs for every supported platform on the direct download links page in the Memgraph documentation.

    

        
        
wget https://download.memgraph.com/memgraph/v3.10.1/ubuntu-24.04-aarch64/memgraph_3.10.1-1_arm64.deb

    

    

        
        
sudo apt update
sudo apt install -y libatomic1

    

    

        
        
sudo dpkg -i memgraph_3.10.1-1_arm64.deb

    

    

        
        
sudo apt-get install -f

    

    

        
        
wget https://download.memgraph.com/memgraph/v3.10.1/fedora-42-aarch64/memgraph-3.10.1_1-1.aarch64.rpm

    

    

        
        
sudo dnf install ./memgraph-3.10.1_1-1.aarch64.rpm

    

Check that Memgraph is running

The package installs a systemd service. Check the status of the service:

    

        
        
sudo systemctl status memgraph

    

If it’s not already running, start it and enable it on boot:

    

        
        
sudo systemctl start memgraph
sudo systemctl enable memgraph

    

Inspect the startup log to confirm the version:

    

        
        
sudo journalctl --unit memgraph --no-pager | head

    

The output is similar to:

    

        
        You are running Memgraph v3.10.1

        
    

You can find the configuration file at /etc/memgraph/memgraph.conf. To fine-tune Memgraph, edit the configuration file. For a full configuration reference, see the Memgraph configuration docs .

After editing the configuration file, restart the service:

    

        
        
sudo systemctl restart memgraph

    

Increase the memory map area limit

Memgraph allocates many small memory mappings. On larger graphs, you can hit the default Linux limit (vm.max_map_count = 65530). Hitting the limit usually surfaces as a hung transaction, munmap errors, or bad_alloc crashes. Memgraph recommends roughly one memory map area per 64 KB of system RAM. For more information, including a list of recommended map count values, see the system configuration docs .

For an 8–32 GB host, 524288 is the recommended starting value. Set it for the current session:

    

        
        
sudo sysctl -w vm.max_map_count=524288

    

To persist the change across reboots, add it to /etc/sysctl.conf or a drop-in under /etc/sysctl.d/, then reload:

    

        
        
echo 'vm.max_map_count=524288' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

    

Verify the new value:

    

        
        
sysctl vm.max_map_count

    

This setting is applied on the Linux host, so it is relevant for both the native and Docker installs. Docker containers inherit the host’s vm.max_map_count.

(Optional) Install mgconsole separately

mgconsole is Memgraph’s command-line client for executing Cypher queries. It is already included in the Memgraph Linux packages, and in the memgraph/memgraph:3.10.1 and memgraph/memgraph-mage:3.10.1 Docker images. You need a separate install only if you want to run it from a different machine.

To install it standalone, download the binary for your platform from the Memgraph Download Hub , or pull the Docker image.

If you’ve got Memgraph installed directly on the host machine, use host networking so the container can reach it on localhost:

    

        
        
docker run -it --network host memgraph/mgconsole:latest --host localhost --port 7687

    

If Memgraph is running in another container or on a remote host, replace localhost with the appropriate hostname or IP address:

    

        
        
docker run -it memgraph/mgconsole:latest --host <memgraph-host> --port 7687

    

For mgconsole documentation, including all command-line flags, see the mgconsole CLI docs .

Run example Cypher queries through mgconsole

With Memgraph running either in Docker or as a native service, you can verify the installation by sending queries non-interactively through mgconsole.

Create two nodes and a relationship:

    

        
        
echo "CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'});" \
  | mgconsole --host localhost --port 7687

    

Read them back:

    

        
        
echo "MATCH (n) RETURN n;" | mgconsole --host localhost --port 7687

    

The output is similar to:

    

        
        +------------------------------+
| n                            |
+------------------------------+
| (:Person {name: 'Alice'})    |
| (:Person {name: 'Bob'})      |
+------------------------------+

        
    

Count the nodes:

    

        
        
echo "MATCH (n) RETURN count(n) AS node_count;" \
  | mgconsole --host localhost --port 7687

    

The output is similar to:

    

        
        +------------+
| node_count |
+------------+
| 2          |
+------------+

        
    

Clear the graph:

    

        
        
echo "MATCH (n) DETACH DELETE n;" | mgconsole --host localhost --port 7687

    

To confirm the graph is empty, re-run the count:

    

        
        
echo "MATCH (n) RETURN count(n) AS node_count;" | mgconsole --host localhost --port 7687

    

The output is similar to:

    

        
        +------------+
| node_count |
+------------+
| 0          |
+------------+

        
    

If you prefer an interactive session, run mgconsole without piping input:

    

        
        
mgconsole --host localhost --port 7687

    

Pattern-matching example

Memgraph’s strength is pattern matching. Try a slightly richer graph:

    

        
        
mgconsole --host localhost --port 7687 <<'EOF'
CREATE (alice:Person {name: 'Alice'})-[:KNOWS]->(bob:Person {name: 'Bob'}),
       (bob)-[:KNOWS]->(carol:Person {name: 'Carol'}),
       (alice)-[:KNOWS]->(dave:Person {name: 'Dave'});
MATCH (a:Person {name: 'Alice'})-[:KNOWS*1..2]->(friend)
RETURN DISTINCT friend.name AS friend_of_alice;
EOF

    

This query returns everyone reachable from Alice in one or two KNOWS hops.

(Optional) Install the MAGE graph-algorithm library

MAGE is an open-source library that extends Memgraph with advanced graph algorithms and query modules such as PageRank, community detection, shortest paths, node embeddings, NetworkX integration, and more. These algorithms and modules are all callable from Cypher. MAGE is a separate add-on. If you want these capabilities, install the MAGE variant described as follows.

MAGE with Docker

Switch from the base image to memgraph/memgraph-mage:3.10.1, which bundles MAGE on top of the same database:

    

        
        
docker stop memgraph && docker rm memgraph
docker run -p 7687:7687 -p 7444:7444 --name memgraph memgraph/memgraph-mage:3.10.1

    

Confirm that the MAGE algorithms are loaded:

    

        
        
echo "CALL mg.procedures() YIELD name WITH name WHERE name STARTS WITH 'pagerank' RETURN name;" \
  | docker exec -i memgraph mgconsole

    

The output includes entries such as pagerank.get.

MAGE with native Linux packages

Memgraph provides a prebuilt MAGE arm64 .deb package for Ubuntu 24.04. It’s installed on top of an existing Memgraph package install:

    

        
        
wget https://download.memgraph.com/memgraph-mage/v3.10.1/ubuntu-24.04/memgraph-mage_3.10.1-1_arm64.deb
sudo dpkg -i memgraph-mage_3.10.1-1_arm64.deb
sudo systemctl restart memgraph

    

For other distributions, or to build MAGE from source with custom algorithms, see Install MAGE graph algorithm library in the Memgraph documentation.

Verify installation by running a MAGE algorithm

With MAGE loaded, you can call any of its algorithms from Cypher. For example, compute PageRank on the small graph that you created earlier:

    

        
        
echo "CALL pagerank.get() YIELD node, rank RETURN node, rank ORDER BY rank DESC;" \
  | mgconsole --host localhost --port 7687

    

For the complete algorithm catalog, see Available algorithms in the Memgraph documentation.

Next steps

You are now ready to build and query graphs with Memgraph on Arm.

Next, you can explore the Cypher query language and the Memgraph data model . You can install the visual Memgraph Lab for browsing and visualizing graphs, and pick a client library for Python, Go, Rust, Java, JavaScript, or C#. You can also join the Memgraph community on Discord .