# Memgraph review: an in-memory Cypher graph database for GraphRAG and AI memory

> Memgraph is a C/C++ in-memory graph database that runs vector and text search next to full Cypher traversal in one query layer. This review covers what it does, how to install it with Docker, and where it stops being the right tool.

**memgraph/memgraph** — High-performance open-source in-memory graph database for GraphRAG, AI memory, agentic AI, and real-time graph analytics. Cypher-compatible, built in C++.

- Repository: https://github.com/memgraph/memgraph
- Website: https://memgraph.com
- Stars: 4,582 · Forks: 283
- Language: C++
- License: NOASSERTION
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/memgraph-memgraph

## What Memgraph solves, and who is actually shopping for it

Retrieval pipelines for AI systems tend to grow sideways. Vector search lives in one service, the relationship data that makes the retrieved chunks meaningful lives in another, and the join between them happens in application code. Memgraph's pitch is that the join does not have to happen there. The README states the project provides "both in a single query layer: built-in text and vector indexes for similarity search combined with full graph traversal, so retrieval pipelines can run as a single atomic database operation instead of being scattered across multiple systems." That is a specific architectural claim, not a general one, and it defines the audience: teams building GraphRAG pipelines, AI memory stores, or agent workflows where the useful context is a connected subgraph rather than a flat list of nearest neighbours.

The second audience is the older one for graph databases. The README lists fraud detection, network analysis and infrastructure monitoring as real-time analytics workloads. Those users care about traversal latency and streaming ingestion from Kafka, Pulsar or RedPanda, not about embeddings. Memgraph serves both groups from the same engine, which is why the feature list reads as two lists stapled together. Whether that is a strength or a sign of unfocused scope depends on which half you use.

It is not for you if your data is tabular and your queries are aggregations. Cypher is a pattern language; using it to do what SQL does well adds a translation layer with no payoff.

## The mechanism: in-memory storage, Cypher, and one query that does search plus traversal

The engine is written in C/C++ and holds the graph in memory, which is where the sub-millisecond traversal claim comes from. The README points to a benchmark page at memgraph.com/benchgraph rather than quoting numbers inline, so treat the performance claim as vendor-published and measure it against your own graph shape.

On top of storage sit indexes. Vector indexes for similarity search, text indexes for keyword matching, and geospatial indexes for location-aware queries. A retrieval query can therefore start from an approximate nearest-neighbour lookup, walk edges outward from the matched nodes, filter by path conditions, and return a shaped result. The README calls this "Atomic GraphRAG" and describes pivot search, graph expansion, ranking and prompt assembly as "a single Cypher query." The practical consequence is transactional: you are not reconciling two systems that can disagree about what exists.

Query language compatibility is with Neo4j's Cypher, and the project describes itself as ACID-compliant and highly available. Availability is coordinated through Raft with automatic failover, which is a leader-based model, so write throughput is bounded by a single leader. That is a normal trade-off, but it matters if you were expecting horizontal write scaling.

Extensibility runs through custom query modules in Python, Rust and C/C++. The MAGE library ships over 40 algorithms in C++, Python and CUDA, covering PageRank, community detection, GNN-based link prediction, temporal graph networks and embeddings. For agent-facing work there is `SHOW SCHEMA INFO`, which the README says returns the full graph ontology for Text2Cypher and agent integration. Handing an agent a live schema instead of a hand-written description is a small feature with an outsized effect on generated-query accuracy.

## Installing Memgraph and running a first traversal

The README does not publish a single canonical install command. It links to per-platform documentation pages: Docker guides for Windows, macOS and Linux, WSL for Windows, Debian and Ubuntu packages, RPM packages for CentOS, Fedora and Red Hat, and a Lima path on macOS that points at the Ubuntu instructions. Kubernetes users are directed to the official Helm charts, which the README says cover both standalone and high-availability deployments.

For a first look, Docker is the shortest path. The README begins the Helm section with a repository add, shown here as it appears before the text is cut off:

```bash
helm repo add memgraph https://memgraph.github.io/he
```

That line is incomplete in the README excerpt, so follow the Helm charts repository for the full sequence rather than guessing at the remaining arguments. If you are not on Kubernetes, use the Docker install page linked for your platform; the README does not reproduce the image name or port flags, and inventing them here would be worse than sending you to the page that has them.

If you want to skip installation entirely, the project runs hosted sandboxes. The README states plainly: "You don't need to install anything to try out Memgraph." The playground at playground.memgraph.com is the fastest way to confirm that Cypher and the graph model fit your problem before you spend time on packaging.

Once connected, the first useful query is not a traversal but a schema read. Running `SHOW SCHEMA INFO` returns the graph ontology, which tells you what labels, relationship types and properties exist before you write a pattern match against them. From there, a Cypher query that starts at a vector or text index match and expands outward is the shape of a GraphRAG retrieval. The README does not print a full example of that query, so build it against your own schema rather than copying a pattern from the repository.

## Where Memgraph is the wrong choice

Memory is the hard boundary. The README describes an in-memory engine and does not document a disk-spilling fallback for the graph itself. If your dataset grows past what the machine can hold, you are not tuning a configuration parameter, you are resizing the machine or changing databases. Analytics workloads often start small and grow without warning, and this is the failure mode that shows up late.

The second limitation is write scaling under high availability. Raft-based coordination with automatic failover means one leader accepts writes. Read-heavy graph traversal scales out; write-heavy ingestion from Kafka or Pulsar does not scale the same way. Teams ingesting a high-volume event stream should size the leader before assuming the cluster absorbs it.

The third is ecosystem gravity. Memgraph is Cypher-compatible with Neo4j, not Neo4j-compatible in every other respect. Drivers, tooling and the accumulated body of Stack Overflow answers are built around Neo4j first. If your team already runs Neo4j and your pain is not latency, migrating buys you a new operational surface for a performance gain you may not need.

Finally, the licence situation is genuinely unclear from the repository metadata. The licence field reads NOASSERTION, and the README shows three badges: APL, BSL and MEL, linking to licenses/APL.txt, licenses/BSL.txt and licenses/MEL.pdf. Three licence files in one repository usually means a tiered model where different editions or features fall under different terms. The README does not explain which code is under which licence, and this review will not guess.

## Memgraph vs Neo4j, FalkorDB and Kuzu: what actually differs

The comparison people search for most is Memgraph vs Neo4j, and the honest answer is that the query language is the least interesting difference. Both speak Cypher. The divergence is in storage and in scope. Neo4j's long-standing model is disk-backed with memory caching, which lets a dataset exceed RAM at the cost of traversal latency. Memgraph holds the graph in memory and targets traversal speed. That single choice explains most of the downstream differences, including the memory ceiling described above.

The second difference is that Memgraph bundles vector and text indexes into the same query layer. With Neo4j, a hybrid retrieval pipeline typically means either a separate vector store or an additional index layer, with the join happening in application code. Memgraph's claim is that the join is a Cypher clause. If your pipeline is graph-heavy and vector-light, this advantage shrinks; if it is both, it is the whole reason to switch.

Against FalkorDB and Kuzu, the axis is the same: in-memory execution with Cypher compatibility versus a different storage and query design. What Memgraph adds on top of the engine is the surrounding surface: MAGE with its 40-plus algorithms, streaming connectors for Kafka, Pulsar and RedPanda, native Parquet and JSONL loading from local disk, S3 or HTTP, and an AI Toolkit with an MCP server and agentic framework integrations. Those integrations are where the switching cost actually lives, and they are also where lock-in accumulates. The more of your agent stack you build on the AI Toolkit, the less the Cypher compatibility matters if you ever leave.

A fair summary: choose on storage model first, then on whether hybrid retrieval in one query is worth the memory constraint.

## Maintenance, releases and upgrade cost

The repository is not archived and the last push was on 2026-09-10, with v3.13.0 released on 2026-09-09, v3.12.0 on 2026-07-15 and v3.11.0 on 2026-06-17. That is a steady cadence of roughly one minor release every six to eight weeks across the visible window. The CHANGELOG.md at the repository root is where the actual breaking-change detail lives; the README does not document upgrade paths or rollback, so treat the changelog and the release notes as the source of truth before any version bump.

The build is non-trivial. The repository carries conanfile.py, conan.lock, conan_config/ and conan_recipes/, and requirements.txt pins `conan>=2.26.0`. There is a build.sh, a CMakeLists.txt, and a package.sh. This is a C++ project with a Conan-based dependency graph, and building from source is a real time investment. Most users should take the packaged install for their platform or the container image rather than compiling.

Upgrade cost scales with how much of the ecosystem you adopt. Engine-only users track minor releases and read the changelog. Users running MAGE algorithms, custom query modules in Python or Rust, and streaming connectors have three more surfaces that can break independently, and the README does not describe a compatibility policy tying those versions together. That is the practical upgrade risk, and it is not visible from the release list alone.

## Licence implications worth checking before deployment

The GitHub licence field for this repository reads NOASSERTION, which means the platform could not classify it automatically. The README displays three separate licence badges: APL, BSL and MEL, each linking to its own file under licenses/. The presence of a Business Source Licence and a separate Memgraph licence agreement alongside an open licence strongly suggests that different parts of the project, or different deployment scenarios, fall under different terms.

What the README does not say is which files, modules or features map to which licence, and whether the BSL or MEL terms restrict commercial or hosted use. This review cannot answer that, and neither can the repository metadata. If you are deploying Memgraph commercially, in a hosted service, or inside a product you sell, read licenses/APL.txt, licenses/BSL.txt and licenses/MEL.pdf directly and get your own legal review. The distinction between an open licence and a source-available licence with commercial restrictions is exactly the kind of thing that does not surface until a legal review or an acquisition.

The related search for Memgraph pricing is a sign that people hit this wall early. The README points to memgraph.com for the product and to the Helm charts for deployment, but it does not carry pricing or licence-tier information in the repository itself.

## Conclusion

Adopt Memgraph if your retrieval or analytics path is graph-shaped and the working set fits in RAM: hybrid vector plus traversal in one Cypher query is the reason to pick it over stitching a vector store to a separate graph store. Do not adopt it as a drop-in replacement for a disk-backed database holding more data than memory allows, and do not treat the repository's NOASSERTION licence field as a green light; read licenses/APL.txt, licenses/BSL.txt and licenses/MEL.pdf first. Verify two things before committing: that the exact Memgraph version you deploy is covered by the licence tier you intend to use, and that your traversal depth and index mix stay inside the memory budget you have sized, since the README documents no disk-spilling fallback for the graph itself.

## FAQ

### Is Memgraph better than Neo4j?

The README does not make that claim. Memgraph is Cypher-compatible with Neo4j and holds the graph in memory, which targets traversal latency, while the README also states that vector and text indexes sit in the same query layer as traversal. Whether that is better depends on whether your data fits in memory and whether you need hybrid retrieval in one query.

### What is Memgraph used for?

The README lists GraphRAG pipelines, AI memory systems and agentic workflows, plus real-time graph analytics for fraud detection, network analysis and infrastructure monitoring. It is also used for streaming ingestion from Kafka, Pulsar and RedPanda.

### How do I install Memgraph?

The README links to platform-specific documentation rather than giving one command: Docker guides for Windows, macOS and Linux, WSL for Windows, Debian and Ubuntu packages, RPM packages for CentOS, Fedora and Red Hat, and official Helm charts for Kubernetes. It also points to hosted playground sandboxes if you want to try it without installing.

### Is Memgraph open source?

The repository is public and the README shows an APL licence badge, but it also shows BSL and MEL badges linking to separate licence files under licenses/. The GitHub licence field reads NOASSERTION, so the terms are tiered rather than a single open licence, and the README does not explain which parts fall under which.

### Is Memgraph in memory?

Yes. The README describes it as a high-performance, in-memory graph database built in C/C++, and the sub-millisecond traversal claim follows from that design. The README does not document a disk-spilling fallback for the graph itself.

### What is Memgraph MAGE?

MAGE is the algorithm library bundled with Memgraph. The README describes it as over 40 graph algorithms written in C++, Python and CUDA, including PageRank, community detection, GNN-based link prediction, temporal graph networks and embeddings.

## Sources

- [Issues](https://github.com/memgraph/memgraph/issues)
- [memgraph/memgraph on GitHub](https://github.com/memgraph/memgraph)
- [Project website](https://memgraph.com)
- [README](https://github.com/memgraph/memgraph/blob/master/README.md)
- [Releases](https://github.com/memgraph/memgraph/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/memgraph-memgraph