I organize community calls for Memgraph community and recently a community member presented how he uses hypothetical answer generation as a crucial component to enhancing the effectiveness and reliability of the system, allowing for more accurate and contextually appropriate responses to user queries. Here's more about it: https://memgraph.com/blog/precina-health-memgraph-graphrag-t...
I was collaborating on the latest feature in Memgraph Lab - GraphChat. To enable natural language querying in Memgraph Lab, we integrated the Lab backend with LangChain and powered this new feature with OpenAI LLM. Let me know what you think if you decide to try it out.
When I am presenting about graph databases, people often ask me about the differences between graph and relational databases so I decided to write a blog post about it.
Hi, author here. I wanted to play a bit with ChatGPT and see how it can help me in creating a graph database. It was really good in conversation about graph data modelling and I think this is where it shined. On the other hand, when giving me information about the TV show, it was a bit confused sometimes. In one run season had 13 episodes, while in the second run it had 9 :') But that was not stopping me from generating Cypher queries with the help of ChatGPT, creating a database and exploring the dataset. I think ChatGPT has a bright future in translating natural language into Cypher queries and in that way speed up the process of learning Cypher to raise graph database awareness.
Memgraph does persist data. Snapshots are taken periodically during the entire runtime of Memgraph. When a snapshot is triggered, the whole data storage is written to the disk. There are also write-ahead logs that save all database modifications that happened to a file.
Well done on your work! It's nice to see new tools being developed in graph world, especially in Rust.
I would just like to emphasize that there is a big difference between a graph database and graph algorithms library. This is a thing that has to be taken into account. Besides that, real life use cases usually include dynamic data. That's the reason why Memgraph holds a set of dynamic graph algorithms. For example, we implemented dynamic PageRank algorithm [1] which is the approximation of PageRank carrying the same information as the results of PageRank - the likelihood of random walk ending in a particular vertex. In use cases such as credit card fraud detection, dynamic graph algorithms are of a huge importance to make important decisions as fast as possible. Besides that, we have implemented a set of modules built on top of NVIDIA cuGraph [2] which provides a set of wrappers for most of the algorithms from the cuGraph repository. With GPU-powered graph analytics from Memgraph you can explore huge graphs databases and make decisions without long waits for the results. [3]
Who ranks better was my word play, because of PageRank :') But yes, I totally agree with what you wrote and I will aim for more detailed comparisons in the next articles. And you are right, NetworkX is easy to use Python library, and I wanted to show that Memgraph is also easy to use and Python friendly, as well as fast. It also has a bunch of popular graph algorithms already implemented, so if anyone is working with graphs and NetworkX, the performance gain of Memgraph introduced in this article may be useful to them. Regarding Neo4j, wait for it ;)
I considered different ways of comparison here, and decided to go with a simple comparison on sample dataset, just to get a feel of it. I did consider doing it all in Python, but then it’s not fair towards Memgraph. Also, it depends on the query we are performing. I could have run a much more complicated query which would give better results, but then again it wouldn’t be fair. If I removed the time counted for filling the digraph, then just the pure algorithm time would be calculated, and the main difference between NetworkX and Memgraph is that Memgraph offers persistance, while NetworkX always has to load the graph into memory. It can be further discussed what would be the best way to do a true benchmark and on what kind of dataset. I did not go into details of the graph type here, but there are for sure cases where Memgraph outperforms NetworkX on much higher scale and on certain graph types. I didn’t claim that we are 5 times faster in any case, just in this certain case. When I do a proper benchmark in the future, I will make sure to be as fair as possible to both sides, and of course to showcase better when to use Memgraph, and when NetworkX, since it all depends on your needs.
Also, thanks for reading it, it means a lot to hear such comment. I get to learn from it too :)
We do have our own implementation of weakly connected components [1]. Currently, we only have NetworkX strongly connected components algorithm [2] as a part of the nxalg module (set of procedures) in MAGE (our graph algorithms library). I did not compare it yet, let me know if you do! We definitely need to create official benchmarks. Lot of work!
Yeah, but this is not an official benchmark, it’s just a simple demo on sample dataset. It would take much more effort to create the whole benchmark to prove how much exactly Memgraph is faster and on what kind of workload.
Yes, I work for Memgraph, I am a developer there and I wrote this, and all of the previously published articles. I was comparing NetworkX to Memgraph algorithms, since that was the point of the whole article. I am mostly using Python in my day-to-day job and I love what they did with NetworkX. This article was influenced by many people who use NetworkX and are a part of Memgraph community. I just wanted to see how much of a difference does the underlying C++ implementation of Memgraph makes. Since I work with Python tools and Memgraph every day, and talk with a bunch of people working on graph analytics, it makes sense to compare by myself and get the facts right.
Yes, I agree. I read this comparison in performance, it's a really good resource, thanks for sharing. It all depends on what are your needs of course. But C++ implementation of graph-tool definitely wins the battle.
I continued learning about NetworkX, and when it comes to issues with scaling and the need for persistence when working on applications in production, Memgraph saves the day. You can see the previous discussion at https://news.ycombinator.com/item?id=33463472.