Memgraph

An in-memory graph database written in C++ that speaks Cypher over the Bolt protocol, with a library of graph algorithms and streaming ingestion from Kafka, Pulsar and Redpanda.

What it is: Graph databases
Type: Commercial product
Made by: Memgraph Ltd
License: Business Source License 1.1 for Community Edition (production use limited to internal business purposes; each version becomes Apache 2.0 after four years); Enterprise features under the proprietary Memgraph Enterprise License
Facts checked: 24 October 2026

What it is

Memgraph keeps a property graph (nodes, relationships and properties on both) in RAM and is queried with Cypher; it implements openCypher, the open version of Neo4j’s language. Clients, the mgconsole shell and the Memgraph Lab UI connect over the Bolt protocol on port 7687. Transactions use multi-version concurrency control with snapshot isolation. To survive restarts, every change goes to a write-ahead log before it is applied, and Memgraph also writes periodic snapshots of the whole dataset; on startup it loads the newest snapshot and replays the log written after it. The default IN_MEMORY_TRANSACTIONAL mode is fully ACID and costs roughly 204 bytes per node and 154 bytes per relationship before properties and indexes. IN_MEMORY_ANALYTICAL skips the per-change records for imports up to six times faster, but gives up isolation, rollback and the write-ahead log. ON_DISK_TRANSACTIONAL keeps data in RocksDB so a graph can outgrow RAM; it is still experimental and has no replication.

The MAGE library adds more than 40 graph algorithms, such as PageRank and community detection, called as Cypher procedures. Vector, text and geospatial indexes work next to traversals in one query, Parquet and JSONL files load from disk, S3 or HTTP, and streams arrive from Kafka, Pulsar and Redpanda. For availability, one MAIN instance takes all writes and any number of read-only REPLICAs copy it, synchronously or asynchronously. Community Edition includes replication but failover is manual; Enterprise adds Raft-based coordinators for automatic failover, plus role- and label-based access control, LDAP, SAML and OIDC sign-in, audit logs, multi-tenancy and time-to-live expiry. Enterprise is priced by memory capacity rather than by query or replica, and Memgraph Cloud runs managed instances of 1 to 32 GB on AWS. Version 3.14.0 came out on 21 October 2026.

Why teams pick it

Data lives in RAM, so multi-hop traversals and whole-graph algorithms avoid disk reads
Cypher over Bolt, the language and protocol Neo4j uses, so Cypher skills and Bolt clients carry over
Built for live data: stream connectors for Kafka, Pulsar and Redpanda, and the MAGE algorithms run on the same instance
Replication to read-only replicas is in the free Community Edition, along with vector search and MAGE

Watch out for

The graph, its indexes and per-transaction state must fit in memory in the in-memory modes; the on-disk mode is experimental, slower and cannot be replicated
All writes go through one MAIN instance; replicas only add read capacity, and automatic failover needs Enterprise
Source-available, not open source: the BSL grant allows production use only for internal business purposes, so offering it as a service, embedding it in a product you distribute or building a competing product needs a commercial licence
The analytical storage mode is fast because it drops isolation, rollback and write-ahead logging; durability then depends on snapshots you take yourself

Good for

Many-hop relationship queriesThe graph lives in RAM, so multi-hop traversals and whole-graph algorithms from MAGE run without disk reads.

Specs

Compare with alternatives →

Data model: Property graph: nodes, relationships, properties on both
Query language: Cypher (openCypher)
Client protocol: Bolt (port 7687)
Secondary indexes: Vector, text and geospatial indexes, usable next to traversals
Transactions: ACID in the default in-memory transactional mode
Default isolation: Snapshot isolation (MVCC)
How it scales: One MAIN instance takes all writes; read-only replicas add read capacity
Replication: MAIN to REPLICAs, sync or async; automatic failover with Enterprise coordinators
Storage engine: In memory with a write-ahead log and snapshots; experimental on-disk mode on RocksDB
Written in: C++
Ways to run it: Self-hosted (Docker, Helm charts), or Memgraph Cloud on AWS
Pricing model: Enterprise priced by memory capacity; Cloud instances of 1 to 32 GB

Alternatives

What all graph databases have in common →Compare side by side →

Neo4jOpen sourceAlso good for many-hop relationship queriesThe best-known native graph database: nodes and relationships stored as linked records, queried with Cypher, self-hosted or as AuraDB.

TigerGraphCommercialAlso good for many-hop relationship queriesA distributed graph database built for parallel traversals over very large graphs, queried with its own SQL-like language GSQL (and openCypher), self-managed or as the Savanna cloud service.

ArangoDBCommercialAlso good for many-hop relationship queriesA multi-model database: JSON documents, key-value lookups, graphs, full-text search and vectors in one engine, queried with one language, AQL.

How it fits with other technologies

What Memgraph uses

Run Memgraph with the MAGE algorithms in Docker, load a tiny graph and rank it · bash

docker run -d -p 7687:7687 -p 7444:7444 --name memgraph memgraph/memgraph-mage

# mgconsole reads Cypher from standard input
docker exec -i memgraph mgconsole <<'EOF'
CREATE (a:Person {name: 'Ada'})-[:KNOWS]->(b:Person {name: 'Bo'})-[:KNOWS]->(c:Person {name: 'Cy'});
MATCH (:Person {name: 'Ada'})-[:KNOWS*2]->(fof:Person) RETURN fof.name;
CALL pagerank.get() YIELD node, rank RETURN node.name, rank ORDER BY rank DESC;
EOF

See it in a real stack

No architecture uses Memgraph yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2016–2026

Dominik Tomičević and Marko Budiselić founded Memgraph in 2016 as a graph database start-up. They aimed it at graph computations on streaming data, and built it in C++ to keep the graph in memory.

In October 2021 the company released Memgraph 2.0 as source-available software under the Business Source License and raised a $9.34 million seed round led by Microsoft’s M12. Tomičević called the licence an “extremely permissive version of the BSL” and said the choice followed Elastic’s licence change and Cockroach Labs’ move to the BSL, both meant to stop cloud providers from selling the software as a service.

Later versions added high availability with Raft coordinators, multi-tenancy and vector indexes, and Memgraph now describes itself as a graph engine for GraphRAG, AI memory and agent workflows as well as real-time analytics. The licence text was amended on 1 January 2026 and limits production use under the free grant to internal business purposes.

Why it’s built this way

The whole graph in memory, with a log and snapshots on disk: The target was real-time analytics on data that keeps arriving, where disk reads per hop would be too slow. The write-ahead log and periodic snapshots let an in-memory store recover after a restart.
Cypher and Bolt instead of a new language: Memgraph implements openCypher, the language Neo4j opened in 2015, so applications and tools written for Cypher over Bolt can talk to it.
A source-available licence: The founders wanted to keep most open-source freedoms while stopping cloud providers from offering Memgraph as a service, the same concern behind Elastic’s and Cockroach Labs’ licence changes.
An analytical mode without transactions: Bulk imports and one-off analysis don’t need isolation or rollback, so skipping the per-change records makes imports up to six times faster and uses less memory.

Timeline

2016
Memgraph is founded by Dominik Tomičević and Marko Budiselić
2021
Memgraph 2.0 released under the BSL; $9.34 million seed round led by M12
2026
Licence amended on 1 January; version 3.14.0 released on 21 October

Sources14 · facts checked 24 October 2026

Improve this page on GitHub