Show HN: Memgraph – Transactional, in-memory, cypher-compatible graph database

Congrats. I'll be kicking the tires with this for some projects at my company.

To answer your first question, the main difference between Memgraph and Dgraph seem to be:

1. The graph model: Property graph for Memgraph vs RDF for DGraph (Depending on the use-case you have one model might be better than the other. E.g ontologies are better served with RDF, whereas graphs with a lot of properties and labels are better served by the property graph model)

2. Memgraph is an in-memory first system where is Dgraph is a disk-based system. Again depending on your use-case and the performance you are looking for, an in-memory system might be better suited.

3. Query language & Ecosystem: we support Cypher and the Bolt Protocol (Same as Neo4j) so we work with a lot of the existing graph tools.

In terms of performance, we don't have official benchmarks yet but we have a few clients that test Memgraph and Dgraph and reported a 3-5x in read performance and about an 8x in write performance for their specific workloads.

I hope this answers your question.

Yes, Memgraph has an embedded Python interpreter so you can run any NetworkX graph algorithm or any other Python code. The code has access to the whole graph, so a bunch of options exists. The entire Python integration is still in the early days, and we have a bunch of plans on how to improve further. What Python libraries do you generally use?

Thank you! We are here to do our fair share and provide the community with the right tools to solve different kinds of graph problems. Exciting space nevertheless and growing fast!

Karim from Memgraph here. That's a good question we get really often. As you can imagine we had our hands full for the past few years building a DB from scratch, and so we didn't really have the resources to put together an open-source project the way we imagine it. It's something we'll explore this year to try to come up with the best way to do it.

Karim from Memgraph here. Thanks for the questions. Are you referring to geospatial capabilities? If I understand correctly, you would like to add geospatial coordinates to specific elements in the graph (e.g. power stations, power lines etc) and be able to search and query for specific areas (e.g. countries, cities, etc)?

If that's the case, although we don't have direct support for Geospatial data format, you can easily encode it into your graph by setting coordinate as a property on your nodes and edges.

Does this answer your question?

The intended usage isn't that one because Memgraph is built as a server database system. The communication has to go via the binary protocol. But, because Memgraph is implemented in C/C++ and there is the C API for the query modules already in-place, offering an embedded solution is possible. This feature isn't high on the priorities list at the moment. What would be your target platforms? Mobile or maybe something on the IoT side?

Thank you! Memgraph has built-in BFS, DFS, and weighted-shortest path. These can leverage the query planning (use the details about data distribution to perform better). Since query modules are introduced, algorithms like Page Rank could be easily implemented. Memgraph offers a couple of them out of the box. Last but not least, all algorithms from the Python eco-system could be run inside Memgraph.

Thank you!

Thank you! So far, Memgraph offers and supports C/C++ library (https://github.com/memgraph/mgclient) and Python binding (https://github.com/memgraph/pymgclient). Node.js is going to come shortly. Please stay tuned!

Thank you!

Dominik from Memgraph here. Good questions!

All editions of Memgraph persist data to the disk via write-ahead logging (WAL) and periodic snapshots for log compaction so even though Memgraph is designed to be in-memory first, data is always backed up to disk. If you enable asynchronous (periodic fsync) WAL, you can trade off a small window of durability for better performance.

Before 1.0, Memgraph leveraged the RAFT consensus algorithm for HA which worked great but had some performance implications. Based on feedback from our users and customers, we have decided to switch our HA implementation to the streaming replication model (similar to PostgreSQL) with automatic failover.

Yea, we're still discussing the exact roadmap on this side. In the short term, the plan is to integrate better with the whole ecosystem. We are still exploring options on the graph NN side. Do you have any specific algorithms to point out? :D

Good question :D We haven't spent much time trying out RedisGraph, nor we ran any kind of benchmarks at his point, but from what I can see, I would say that the main differences would:

1. Memgraph is a native GraphDB which means that it's specifically engineered to support graph and graph only whereas RedisGraph is a module that runs on top of key-value store (nothing wrong with that, but it might have some limitation when it comes to performance on complex graph algorithms and traversals)

2. Cypher coverage – We cover about 80% of the cypher query language, where I think RedisGraph covers only a small portion (But I hear that they're improving on that)

Apart from that, I guess you would really need to test both when for specific use-cases to judge performance and scalability. We'll try to provide some benchmarks in the next few weeks.

I hope this helps :D Have you used RedisGraph? Any thoughts?

Thank you! So, Memgraph is compatible with Cypher (http://www.opencypher.org) query language and Bolt protocol (https://boltprotocol.org) which means that existing tools and workloads will work. When it comes to the differences, because of our in-memory first approach, low-level implementation and optimizations Memgraph is more suitable for real-time analytical graph workloads. Please let me know if this makes sense or you would like to learn more about specific details. Out of curiosity, do you have an interesting real-time graph use-case?