 I'm excited about this topic because it was a lot of fun to build. It was also a lot of fun to use. And graph algorithms with graph database. And today I want to talk a little bit about why we built how you can use them and kind of where the future is. My name is Michael. I've been working with B4J for eight years now and kind of part of the battery. So basically what graph algorithms give us is an insight into structure. So we have a lot of data that we get from all over the world, lots of different sources. And you can analyze this data kind of in a local space so by doing a graph pattern query like you think for. And then we kind of look at a name on a certain node but we want to basically also be able to analyze and analyze the world structure of the ground and take this information to get what it says. And so I want to talk a little bit about that and then look at what does, why does graph analytics work now as well. It didn't work so well before. And then we want to look how you would run such pipeline and what you need to take about networks. I hope I find enough time for the demo. I have a bunch of demos. Basically there are different things that you can get from analyzing graphs. So one is that you can look at what information flows through a network such as if you have an energy distribution network or another distribution network traffic and so on and what happens if you interrupt this network and so forth. What are the crucial points of this network if you kind of have a power station shut down and that's where the critical parts and large parts of your network can go dark because then you kind of destroy the critical part. The same is true for traffic. All of you that have spurt type and traffic jams I know that oftentimes it's just one junction that keeps all the traffic kind of back and then if you resolve that then everything is okay again and so these kind of individual points in the network can have a lot of impact in congestion, failure and so on. Other things that you can get from past analysis is for instance efficiency in routing so for internet protocols but also for other flows of information, for flows of money and also other things like energy and so on. You also want to have alternative ways. You want to have the most efficient way, the most cost efficient way to get data from A to B and there you also have to analyze a lot of parallel paths to find the most efficient ones, things like shortest path search, routing navigation in general is something else. And then the other thing that's really interesting is that we can just by looking at a structure of graphs we can already infer a lot of, of the global structure we can also infer a lot of the like local structure. So how many communities or clusters do exist in the past? Who connects clusters? Who's influential in the cluster? So I can see for instance all the people that are interested in a certain topic and whom would I have to talk to for instance to spread an idea within this group or if I have people living in a country and they are forming also clusters because you have organization and so on and there's for instance a disease spreading in this country. Where do I have to look for instance to stop this disease from spreading by vaccinating the right kind of people for instance and then kind of stopping the epidemic in its initial point. The same is true for information flow. So who are the influencers in networks and as we've seen with the U.S. election for instance and also other elections that you can by placing kind of influential bot networks in the right places you can influence outcomes of political decisions pretty easily today. So there's a lot of stuff that we can learn from from graphs in general. Why does graph analytics take off now? The animation is a bit too much I didn't get it. Because we have now the compute power available. So one aspect is that we have now the data available so we can get data from many different data sources. We can combine data sources. We can bring things together. So one example is the Panama Papers data set where the journalists of the ICIJ collected, got the information from the leaks from the law firms that create shell companies but then they augmented this data with sanction lists, census information, company registries, ownership information, property ownership and kind of by bringing all these networks together they got a much complete picture of reality more or less. And that allows them to do these observations. And on the other hand we have also the compute infrastructure available. Now at the swipe of your credit card you can command like thousands or tens of thousands of CPUs and exabytes of RAM more or less at your proposal. So you can also use all the compute capacity to work with this data. And the two things coming together kind of made it possible that we now can do these kind of analytics much easier. We saw from Jerry how easy it is for instance with Spark to just grab the data and put it on Spark on a Spark cluster and compute it for instance something like the Bitcoin. Okay, we can get a lot of insights from graph algorithms. I already mentioned things like failure points, structures and so on. But we can also do things for instance we can enrich networks for better recommendations by understanding human behavior pattern. So who did what in the past and also how things are related to each other at larger scale. How do I do kind of compute similarities between large intersections of items in a retail store or of movies or of videos. Things like Netflix created a micro categories for movies from like analyzing your behavior and analyzing on the other side kind of content information about movies that they had and this is all possible by kind of taking all this data structure and running algorithms on top of that. Basically classical graph algorithms give you things like metrics so what are centralities of nodes so what's important, what's the influence of a node, what are clusters that we can find, what are other structure insights that we can get. But then on top of that we can also apply machine learning on graph and extract embeddings for each node so that means a node with a certain structural environment and their properties can form an embedding for machine learning algorithm as an input and then we can use that as well to not just classify and predict information but also use the deep learning algorithms to detect for instance structures that are at higher levels that we want to see so you can use for instance things like convolutional networks to also find structures in graph structures and not just in images so that's kind of really interesting aspects. Something else that's really interesting is that actually all the neural networks that you use in deep learning are actually graphs so they are kind of neurons connected with edges with weights so you can also kind of put them into a graph or graph database or in graph analytics system to get more insight of how does this neural network actually work, what are actually influencing aspects which parts kind of participate in how in decision making and so on. So that's pretty amazing so that's something that you're currently looking into the right side and graph algorithms is something that we've already been working on. Structures can hide in the graph. One example that I really liked a lot is Game of Thrones. Andrew Beverage and Mathematician from California took all the Game of Thrones books so all the five books that we have right now because Vince of Winter is not coming out yet and analyzed character interactions so he looked at a book text and looked at which characters appeared within 15 words of each other so that was one character talking about the other character, two characters interacting or one character killing another character and what do you do usually and so he found in total more than 7000 interactions of characters and put them all into an interaction network and then just random graph algorithms on that and basically what these graph algorithms do is they get the same kind of insight that you get from reading the books so when I read the books that I know for instance that Tyrion is very influential because he's kind of involved with a lot of people and kind of doing all like his intrigues and so on but the graph algorithm also gets the same kind of insight so if you look at for instance things like page rank or so then here Jon has a higher page rank and Tyrion has the highest page rank so he's the most influential person in this kind of interaction graph which I also know because I've read the books but a stupid graph algorithm can't understand the books and they are like literally content can come to the same conclusion and that was quite an impressive thing for me to see how do you run graph algorithms so in the past there were already many ways of running graph algorithms on Spark with GraphX or GraphFrames on Apache Flink on Giraffe on Tori from Martin and the Booth library and so on so there are many ways of running many ways of running graph algorithms but what we from Neo4j wanted actually people using Neo4j is that they don't have to so many moving parts so that they can just take the data that they already have in their graph and just run graph algorithms on top of that without having the additional things to do so what you also wanted to avoid is kind of to transfer data so for instance the bitcoin graph that Jerry showed before I wanted to copy the data from one machine to another and it was like 600 gigs of data took like over 8 hours to copy over the network so if I transfer these large amounts of data over a network which is kind of not fast enough then it also takes some time to do all the data transfer and scalability is more an issue with classical tools like iGraph and Python or NR where they are bound to a single machine and a single CPU and that sometimes also a problem so we had an example from a partner company of ours called Write Relevance they did Twitter analytics on the US elections and Brexit data and also on other data like Ebola data and so on and they ran a pipeline like this so they ingested the gutter tweets from the Twitter streaming API, put it first in MongoDB then moved them over to Neo4j and then did some querying and aggregations in Neo4j but then exported the data to TorR ran certain algorithms in iGraph and then they took some of the data wrote it back to Neo4j and had like a cycle of iterating there and then they used MySQL to put the data into Tableau and exported it into GraphML to get it into Gaffee so it's kind of the whole shebang of things that you can have so it's like a hodgepodge of things and so we were talking with them and they said we really would like to simplify this pipeline and make it easier and remove lots of these kind of additional parts that we don't really need, we just needed them because the capabilities were not there and so we looked at it and we said okay actually if you talk to us anyway then we can also kind of remove these things right so because we can access Twitter streaming API directly from Neo4j and put the tweets directly into the graph with the new graph algorithms we don't need the iGraph stuff in R anymore, there's a Tableau connector for Neo4j and there's also a Gaffee integration for Neo4j so actually if you already want to focus on Neo4j as your data store then you can do all of these things without the other moving parts and the thing that was kind of missing back then was the graph algorithms and that's something that we worked on since so what can we do in terms of graph analysis in Neo4j, originally Neo4j is a transaction database so meaning it's meant for transaction in workloads so you can build like a retail system with that or an ordering system or a hotel reservation system or something like that where you have lots of small transactions going through the system, lots of rates, lots of writes but not like large scale analysis that was not kind of the focus of Neo4j before but you could already do some analysis by using Cypher and just running Cypher over your graph data for instance to compute something like degrees or compute small clusters and stuff like that but that was not really efficient what we added as an additional capability to Neo4j was that we can implement now user defined procedures and functions so that means you can write your own code which then becomes callable from Cypher so you can keep your regular Cypher statement but at certain point you want to for instance do something custom business logic or you want to run an algorithm or you want to do a special conversion or you want to reach out to another database to pull in some additional data that you need to do with these additional procedures which you then also use as the approach to implement the graph algorithms so all the graph algorithms that I will show you are also implemented as user defined procedures so you can just call them from your Cypher statement that means you can have an already existing Cypher statement that computes certain aspects and then you just pass parts of these results into the graph algorithms procedures and then they can use that and with the results that come out of the graph algorithm procedure you can also again reach into your graph and pull for instance additional information for these nodes and relationships and all of that runs on Neo4j so you don't have to leave like Neo4j's process but it's all running in process for Neo4j which is kind of really nice and not just on a single node so we can also run these graph algorithms on dedicated compute nodes in a Neo4j cluster so if you have like a regular cluster that runs your transactional workload then you can also add a bunch of machines that are larger sized and run as like reporting or compute instances and then you can run these graph algorithms on these machines so far we implemented algorithms from three areas we did centrality algorithms community detection and pathfinding algorithms basically you use them like use every other user defined procedure in Neo4j you can call them with the call syntax and then you have each algorithm has a name so prefix with algo then the algorithm name and then you have two variants one has a stream suffix which means it gives you the data back to your query so imagine you run a page rank then you get all the nodes and the score back to your query which is okay for medium sized graphs but if you stream back like a billion nodes to the consumer then it's pretty hard to handle that kind of on the fly and that's why we also have a second variant which doesn't have the stream suffix which just writes the data back to the graph so each node for instance would get their score directly written to as a property which is quite convenient because then you have it materialized in the graph and then you can for instance also use these scores in your regular graph queries as well so for instance if I computed already centralities then I can also just use them in my next query for instance to find what are relevant people or what are relevant products or relevant movies that have a higher centrality score than other ones and can use that to improve for instance the quality of recommendations so that's the basic approach and as parameters you pass in optionally a label that you want to have or a type, a relationship type and then some additional configuration depending on the algorithms something like dampening factor or iterations or weight information and so on and that's one aspect and the other thing is that you also want to have these projections so if you were here for years Toki said that he actually had to create two separate graphs one for the whole Bitcoin data model and one that had only transaction to transaction information so like a bipartite graph and what we can do in these algorithms that instead of passing in here labels and relationship types you can also pass in one cipher statement that creates a node list, one cipher statement that creates an edge list and then it uses this virtual graph to run computation so you can take any graph data that you have already in your graph and just project it to whatever you want to have so for instance you have a twitter graph with users, tweets, hashtags all this other stuff and mentions and retweets and replies and for instance you want only to have the user-to-user mention graph right then you just write here find the old users and then find the user who posted a tweet which mentions another user and return the user one and user two and then perhaps the frequency as well and then you have a virtual projected graph which then the algorithm is run on and so you can project your graph into any shape that you need or what to have for any these algorithms ok so what did we implement, we implemented in terms of centrality's page rank as a baseline algorithm between the centrality close and centrality, decrease centrality was already there in Neo4j out of the box, harmonic centrality as well and we are also looking into some other ones and here's an example for page rank on dbpedia so we can just run page rank on dbpedia stream the results and pass in label and relationship type and then return just the top 20 nodes from dbpedia and the same I can do with writing the data back and then I can pass in a write property where I can also say I have different properties that I want to write to, for instance I can say I want to run page rank for this subset of my graph and write to property A and I want to run for this other subset of my graph and write it to property B and then I get this statistics information back how long did it take to compute the data how long did it take to write back the data to Neo4j so for community detection we have currently a little propagation unifying so we can connect the component strongly connected components and we also added a triangle counting which is not really a community detection algorithm which was quite interesting and things that we want to look into going forward is something like walk trap and info map as higher quality community detection algorithms and here are examples again so this example look similar but in the demo section we see then kind of how they work in detail and for path finding we have single source shortest path all nodes single source shortest path multi-source breadth-first search and then also in general parallel breadth-first search and depth-first search implementations that are mostly used by the other algorithms as an infrastructural thing but also exposed in the library itself and there's also Dijkstra implemented as a parallel Dijkstra as well okay here's for instance an example where I find a starting node and find all the single source shortest path and write the properties back to the relationships in between so what allows us to have these algorithms available we can, as I said before we can combine lots of different data sources into one graph, run our compute we can project the existing graph to certain sub-graphs and enrich the data that we get with the other algorithms and then we can use this to run queries on top okay cool demo time let's see so first of all when you use Neo4j desktop then it's quite easy to install these algorithms so basically the graph algorithm library I have links in the end is an open source library which is on github and so you can find it on github documentation is also there and also the releases so you can also just grab the job for the algorithm and put it into Neo4j server as a plugin or if you are running Neo4j desktop you can also just click on the plugins tab and then install graph algorithms here with a single click as well so it downloads the correct version of the graph algorithms, adjust the config and puts the job into your folder so if I look here on my plugins folder it has APOC and graph algorithms installed okay and this is the game of stones graph so I can actually look at the Neo4j browser for this graph and so first of all when you look at this data we just see our characters what's wrong here with my computer demo demo gods oh there you go so this is kind of a small subset of these nodes here with a bunch of other people and here you see that we have different I can also make this bigger different interact relationships so we have for each of the books you have a different interact relationships so we can also kind of discern things from the different books and so you see here we have attacks 1, 2, 3 and 4 and 5 so the books 4 and 5 were actually only one book but George R. Martin split it into two so what we can also do is we can just see how big is the graph of course make it so it's 800 nodes and 3,000 something relationships I think 3,800 relationships so we can also look at like degrees so we can just find all the characters and then return just the size of the VPN just the size of the nodes as degree and so these are the nodes with the top 5 degrees let's perhaps return the name so this is kind of the degree centrality which I can already do out of the box so there's nothing that we have to do in particular so but if you take this network now and want to run some of the graph algorithms on top of that what I first can run is APOC nodes oops aesthetically nodes create distribution so we can start running algorithms on top of that you can look at this degree distribution first and see what's kind of our minimum maximum degree of 148 maximum degree and then average as 6.5 with a standard deviation of 14 and now we can run algorithms on top of that what's wrong here so here in this case we run the patron algorithm and we run the stream version so that's the version that returns the data to us directly and and we get back the node and it score and we want to have for the top 5 nodes we get the node name back and the degree of the node as well so and it runs a patron over the whole graph and gives us the stuff back so we have got Turing Lannister Stennis Perathia and Tywin Lannister have the highest patron over all the books and that's their degree and so we see even as Theon Greyjoy has a higher first level degree its page rank is lower so because not so many people are connected to Theon Greyjoy as for instance to Turing Lannister also as to Tywin Lannister in the second degree we can also use that to write the data back to the graph so that's actually pretty simple so where we can just call algo.pagerank which runs pagerank on our graph with 20 iterations and writes this data back to the pagerank property so from now on I can also just give me the character the ones that have a pagerank because some of them also don't get one and then so and now I have these properties directly on my nodes and can use them for photo scoring for instance so similarly we can compute between a centrality so here we take just between a centrality between characters from the first book and then find a character and because you get just notary back and here we see for instance that between a centrality is a metric that is high for nodes that connect clusters of other nodes so for instance Eddard Stark is someone who connected many of the different groups in the first book right because after the first book Eddard was not not anymore the same is true for John Snow and also for Rob Stark in the first book and Robert Baratheon and Turing was actually very limited in terms of interactions so in the first book he was only in the group of the Lannisters this changes later where he becomes more involved but actually look in the books four and five if Turing has a better between a centrality no Stanis is still there really high and Jamie interestingly and Daenerys okay what else can we do we can run clustering on this and here I wanted to show you how you do the decipher projection so I just do the first statement which returns characters as no list and then the second statement is all the interactions and we have just two characters and we can hear some the weights of the relationships so each of the relationships in the interaction graph has a weight which is the frequency of interactions and we can also use that for computing the communities so in this case with label propagation and we write it to a community property here so we can just run this on this graph that runs in a few milliseconds and then we can fence this look at the communities and the sizes so the query here finds all characters that have a community property and then counts the groups then by community so we see we have some larger communities with more than a hundred hundred fifty and then it kind of goes down really quickly to small communities of a few people and if you look at one of these communities actually so for instance I had here the one with community hundred twenty four somewhere down here with only eight people I want to see what was actually in this community and if you look at the graph then we see that something that I didn't want to see so this is record oh that's not what I wanted to show anyway I think there is something from something that I ran before so we can do the same with Louvain and instead here we write to the Louvain property and let's see if this works now and here we get the same community sizes again you see that Louvain is more evenly distributed and here we can for instance this should actually be the network of Queen Cersei here we see Cersei in the middle and all the people that we know from her interactions like Baron Tren and the Clegane's are in here and the where is he the other Lannister Lannister Lannister and so all the people around Queen Cersei are in this cluster around her so you can really identify if you have the story then you actually know all these clusters that you see here in these in these clusters actually making sense for you that's actually quite cool okay cool here's an example for the for the projected Twitter graph that I mentioned before so I have Twitter users and here's a mentioned graph so a Twitter user to another Twitter user we are mentioned in a tweet and then we can just compute for instance page rank on top of this virtual graph which we just projected my next example is dbpedia so I mentioned before dbpedia is a data set of 11 million nodes and 16 million pages links between pages and we can just run some algorithms on top of that and if my network works let's see it doesn't look like it so let's see come on you can do it it worked all the time while I was watching the other talks it's just not working when I'm doing my own talk but I'm getting funny characters and an edge connection anyway that's a little bit frustrating but I think I have it here as well so to run page rank on this graph with 11 million nodes and 117 million or 60 million relationships takes 20 seconds which is kind of nice with 20 iterations and union find runs I think in 40 seconds also on dbpedia so clustering on dbpedia which is kind of a copy of the dbpedia pages with all the links between each other which is kind of nice and if you run something like page rank and get the results back by ranking then we see that pages like united states, animal friends list of sovereign states these kind of listings pages are always really high up in the page rank because they have a lot of links pointing to them because it says all these people are all these states are sovereign states. Germany shows also up here's another projection example for instance if we say we only want to have pages where there's Europe in the title and run only on page rank between these pages that are just a subset of my graph then I can do this as well and this is my node list and my edge list and then we can run this I would love to show it to you but it seems that the network is not liking me at all okay so be it okay so we can do also funny stuff so on the clustering and in dbp what we can also do is if we run something like a centrality like page rank first and then a clustering algorithm we can also use the centrality score to find the nodes of the cluster that are like the central nodes globally but in the different classes so for each cluster we can also find the node with the highest page rank for instance return this as this is the most influential node globally in this cluster for instance so we can also see how these are distributed across the clusters and then also visualize that in Neo4j itself we also did some bitcoin analysis not as much as jerry but I got some cool inspirations from this talk so I will definitely do some more so Greg Walker is someone who runs a Neo4j graph on the side it's called learn me a bitcoin and he continuously imports all the bitcoin transactions that come along into the Neo4j graph so currently this graph has 1.7 billion nodes and 2.7 billion relationships so it's 240 million transactions 208 million addresses and 650 million outputs 600 gigabytes on disk right now so the data model is a little bit hard to see here so we have a transaction in the middle which is linked to a block and then each block has inputs and outputs where's the output where's the input so here's the output the output is pointing or locked to an address the input is also locked to an address and then there's also the coin base as a starting point for the blocks and first on this large graph was to do a degree distribution for the locked relationship and something that was relieved for me at least was to see that actually although we have 650 million locked relationships in this graph like the 99.9 percentile only has 28 lock relationships so the degree distribution of this relationship is super tiny and then there are a bunch that have like 18 million or something or 1.8 million locked relationship and Greg explained it to me because I'm Bitcoin loop so I don't know these things and he told me actually people usually in Bitcoin when they transfer money they create all every time new addresses so they're not traceable so you don't you wouldn't send kind of multiple transactions with like the same address with the same wallet address and that's why most of these addresses have only one transaction also originating from it so you can't trace them kind of via multiple transactions and the addresses with these 1.8 million in most cases are either payment addresses where like someone posted publicly a payment address or ransomware so if you do ransomware you also have to post your Bitcoin address so people can pay you right and so that's actually something that you can find and trace really well in Bitcoin graphs these kind of all ransomware payments and you get like a lot of payments coming in can follow the flow of information so on the on the Bitcoin graph on the 600 gigabyte graph this ran in 300 seconds and then as the next thing I wanted to see kind of this kind of address to address virtual networks so kind of looking at which addresses send which what amounts to to other addresses so I ran and projected graph again so with output and locks so you see this data model is a bit more fine-grained than the one that GA used and then I do the same on the on the edge list as well I find these locks the first 10 million I think is it and so these are my two addresses so address one and address two and then I just ran the algorithm on that and on these 10 million and notes it runs in 300 seconds a cluster which have a lot of members like 4.4 million or something like that 4.4 million members so a really large cluster of people exchanging money but then there are also a number of smaller clusters here that come out of that so this was some experiments that I did on the Bitcoin graph about the implementation of the graph algorithms basically we wanted them to be really easy easy to use so that means whenever I can write a cipher statement I also want to run be able to run my graph algorithm so that's why we added them as a user defined procedure so you can just call them from your cipher and there's no extra tooling or infrastructure anything that you have to set up if you didn't want to have data transfer could you close the door or come really loud out we didn't want to have data transfer we wanted to run these algorithms in the Neo4j process which is still live running transactions so it's not like that we stopped the Neo4j instance to run the algorithms on but we can say okay use a concurrency of x which is the percentage of your total number of CPUs and the rest of the Neo4j database continues to run transaction workload at the same time while it's also running the graph algorithms we wanted to parallelize everything so make use of all the CPUs that we have available so both the loading and data structures computation writing back and we also used a lot of low level Neo4j APIs to access the low level data structure, data in Neo4j really efficiently and of course we wanted to scale to billions of nodes and relationships and using hundreds of CPUs and terabytes of RAM easily with these algorithms and basically the architectures like this so here is our algorithm implementation we are accessing Neo4j in parallel to get the data into our data structures, run the algorithm in parallel and write the results back to Neo4j and as you can see for instance this is an edge top from a machine with 144 CPUs which runs page rank and they are all pretty busy so that's kind of nice so we really utilize the GPUs really well and something that I actually was surprised by because I didn't expect that is that it actually performs quite well if you compare it to the published data for instance from Spark's GraphX so for the Twitter 2010 data set which is 1.5 billion relationships and 40 million nodes it's about in the same order of magnitude as GraphX and the blue one is GraphX and the green one is Neo4j so I expected it to be an order of magnitude slower but actually a little bit faster so it's kind of nice so mission accomplished in this space something that we started with initially was to limit these graph algorithms to 2 billion nodes and 2 billion relationships so that we can use integers everywhere which makes it much faster to do something but now we are rewriting them to use a long ID so we can run to arbitrary sizes so here's an example of a 300 million node and 18 billion node graph that has 600 gigs on disk and a page rank with 20 iterations on one machine with 20 threads runs in which is pretty good and the same for triangle counting on this machine with the same 18 billion relationship graph runs in 3 out of 40 minutes which is also quite nice so I was quite happy about these results and the new implementation that we have for the large graphs is even more memory efficient than the old one because we do data compression of numeric integer areas and two segments so it's pretty nice and I'm looking forward so we are currently migrating all the other algorithms as well to the huge implementation and then looking forward to test this all out and report these results back so this is kind of the scale that our customers want us to build for so they wanted to have up to tens of billions of nodes and hundreds of billions of relationships to make this work so it's mostly like large payment networks and people with lots of user transactions so sites that have hundreds of millions of users and they want to run there so all this stuff is out there and available so you can just grab it it's on GitHub you can try it out with Neo4j desktop or install it into your Neo4j server we'd love to get feedback we'd love to hear from you if it worked for you, were there anything that you would like to have different are there certain algorithms that you would like to see are there things in terms of usability that should be different or better and so from that perspective there are also a bunch of other examples where people wrote blog posts about using these graph algorithms on other data sets so Tomasz Pratnik did it with Game of Thrones extensively and with the Yelp data set from Kaggle my colleague Will did it on the Russian Twitter trolls that have been published by NBC and the US Congress ran graph algorithms on top of that and then we also have it we ran it also on Paradise Papers and Panama Papers as well and I want to do more about the Bitcoin analysis that will be a lot of fun okay cool most I didn't do much of that except for starting the whole effort and then nudging people to do stuff all the implementation was done by Paul and Martin from Dresden from Avangard Labs which was really cool and Tomasz looked a lot on the docs and my colleague Mark is taking the project over now for me and runs it from now on and actually he released just yesterday a new release of the graph algorithms which have a new of the larger scale algorithms implemented and is available now on github and maybe in as well okay and with that I'm done even in time any questions from you yeah so the question was is there any way of monitoring the progression of algorithms so the algorithms output progress into Neo4j's log files so if you look at the log files you see where the algorithm is if they can be loading or writing and also all the threads are outputting that you're also thinking about exposing that for instance via monitoring tools so you can also access it via monitoring or even try to make it work so that the output the algorithm actually outputs like cipher records and then kind of here streaming you would see like the records appearing one by one but I have to first try out if it actually works across all the different layers of the stack to see that any other questions