back to indexAI Engineer World’s Fair 2025 — GraphRAG

00:00:03.740 |
we got a very good question from the organizer. 00:00:12.440 |
How many of you have implemented reg in production? 00:00:18.840 |
So I can say with high confidence, reg is not dead. 00:00:34.380 |
Why, wrong analogy, why build a network tower 00:00:42.440 |
So I think that is how I see reg being important. 00:00:49.460 |
So I'll stop there, we'll talk more in my presentation, 00:00:53.960 |
but I'm waiting for 11:15 because this session 00:01:15.120 |
To quickly introduce myself, my name is Mitesh. 00:01:16.980 |
I lead the developer advocate team at NVIDIA. 00:01:19.580 |
And the goal of my team is to create technical workflows, 00:01:25.140 |
and then we release that code base on GitHub. 00:01:27.920 |
So developers in general, which is me and you, all of us together, 00:01:32.980 |
we can harness that knowledge and take it further for the application 00:01:38.720 |
So that is what my team does, including myself. 00:01:41.340 |
In today's talk, I'm going to talk about this project that we did 00:01:45.280 |
with one of our partners and some of my colleagues at NVIDIA 00:01:49.540 |
and our partner about how can we create a GraphRack system, 00:01:53.480 |
what are the advantages of it, and if we add the hybrid nature to it, 00:02:02.560 |
I will not be able to give you a 10-fit view where I can dive 00:02:08.420 |
with you in the code base, but there is a GitHub link at the end 00:02:11.140 |
of this talk which you can scan, and all these notebooks, 00:02:15.580 |
whatever I'm going to talk about, is available for you to take home. 00:02:19.580 |
But I'll give you a 10,000-fit view if you are trying to build 00:02:22.080 |
your own GraphRack system, how can you build it? 00:02:26.180 |
So a quick refresher, what is knowledge graph, and why are they important? 00:02:32.920 |
So it is a network that represents relationship between different entities, 00:02:42.600 |
A simple example would be me being here, what is my relationship 00:02:46.320 |
to AI World Fair Conference, AI Engineers World Fair Conference, 00:02:49.980 |
and my relationship is I'm a speaker at this conference. 00:02:52.560 |
What is my relationship to anyone who's attending here? 00:02:55.300 |
Well, our relationship is you attended my session. 00:02:58.560 |
So this edge of relationship between the two entities becomes very important 00:03:03.840 |
to which only graph-based network can exploit, or knowledge graphs can exploit. 00:03:09.520 |
And that is the reason why there's a lot of active research happening in this domain 00:03:13.920 |
of how you can harness GraphRack, how you can harness knowledge graph and put it into a Rack-based system. 00:03:22.660 |
So the goal is three things, how can you create a triplet, which defines the relationship between these entities 00:03:31.180 |
that GraphRack are a graph-based system or knowledge graph is really good at exploiting. 00:03:36.400 |
And that's what is unique about this knowledge graph. 00:03:41.780 |
So if you think about why can they work better than semantic Rack system, 00:03:50.120 |
well, it captures the information between entities in much more detail. 00:03:53.660 |
So those connections can provide a very comprehensive view of the knowledge that you are creating in your Rack system, 00:04:03.040 |
and that will become very important to exploit when you are retrieving some of that information 00:04:07.700 |
and converting that into a response for the user who is asking that question. 00:04:12.920 |
And it tells the ability to organize your data from multiple sources. 00:04:18.300 |
I mean, that's a given, no matter what kind of Rack system you're building. 00:04:22.300 |
So how do we create a GraphRack or a hybrid system? 00:04:27.260 |
So this is the high-level diagram of what it entails. 00:04:32.380 |
The very first thing is your data, you need to process your data. 00:04:35.480 |
The better you process your data, the better is the knowledge graph. 00:04:38.120 |
The better is the knowledge graph, the better is the retrieval. 00:04:40.580 |
So four components: data, data processing, your graph creation, 00:04:44.120 |
or your semantic embedding vector database creation. 00:04:49.380 |
Those are the three steps, and then the last step is, of course, 00:04:51.960 |
inferencing when you're asking questions to your Rack pipeline. 00:04:56.620 |
And at a higher level, this can be broken down into two big pieces: 00:05:04.840 |
So all your data processing work, which is a one-time process, is offline. 00:05:10.580 |
And once you have created your knowledge graph, which is your triplet entity 00:05:16.120 |
relationship, entity two, or your semantic vector database, once you have it, 00:05:21.760 |
then it's all about querying it and converting that information into a response 00:05:29.340 |
It cannot be something that, here are the three relationships, and then we, 00:05:33.800 |
as the user, have to go figure out what does this exactly mean. 00:05:39.340 |
So the top part of this flow diagram is where you build your semantic vector database, 00:05:47.980 |
which is you pick your documents, and then you convert them into vector embeddings, 00:05:56.720 |
So that piece is how you create your semantic vector database. 00:06:02.100 |
And then the piece below is how you create your knowledge graph. 00:06:05.500 |
And it is much more, there are much more steps that you have to follow, 00:06:11.360 |
a care that you have to take when you're creating your knowledge graph. 00:06:19.040 |
So diving in the first step, creating your knowledge graph, how can you create those triplets 00:06:23.420 |
out of documents that are not that structured? 00:06:26.540 |
So creating triplets, which exposes the information between two entities, 00:06:31.620 |
and picking up those entities so that that information becomes helpful is very important. 00:06:37.560 |
This document is of ExxonMobil's results, I think, their quarterly results. 00:06:43.300 |
And we try to pick up the relationship or create the knowledge graph using an LLM. 00:06:50.780 |
And if you see at the first line, it's ExxonMobil, which is a company, that's the entity. 00:06:56.240 |
Cut is the feature of that entity, spending oil and gas exploration and activity. 00:07:05.460 |
Cut is the relationship between ExxonMobil and spending on oil and gas exploration. 00:07:10.260 |
And activity is the name of the entity, spending on oil and gas exploration. 00:07:16.240 |
So this is how the relationship needs to be exploited. 00:07:19.060 |
Now, the question that comes to our mind is that sounds very difficult to do. 00:07:26.540 |
And that is the reason why we need to harness or we need to use LLMs to figure out a way 00:07:31.420 |
to extract this information and structure it for us so that we can save it in a triplet format. 00:07:41.760 |
Prompt engineering, but we need to be much more defined about it. 00:07:46.920 |
So based on the use case that you are trying to work on, you can define your oncology. 00:07:53.240 |
And once you have defined your oncology, you can put it in your prompt and then ask the LLM 00:07:59.100 |
to go extract this information that is oncology specific from the documents and then structure 00:08:05.280 |
it in that way so that that can be stored in the form of a triplet. 00:08:11.040 |
You might be spending a lot of time here to make sure your prompt is doing the right thing 00:08:15.740 |
and it is creating the right oncology for you. 00:08:18.380 |
If your oncology is not right, if your triplets are not right, if they are noisy, your retrieval 00:08:24.540 |
So this is where you will be going back and forth figuring out how to get a better oncology. 00:08:30.380 |
So this is where you will spend, this is where you will spend 80% of your time to make sure 00:08:38.020 |
you get the oncology right and you will be going back and forth in an intuitive manner to see 00:08:45.020 |
And then the next vector database for a hybrid RAC system is to create the semantic vector 00:08:52.760 |
And that is very reasonably straightforward or it is well studied. 00:08:57.640 |
This is the first page of attention is all you need research paper. 00:09:00.680 |
And you break it into chunk sizes and you have another factor called overlap. 00:09:06.400 |
And chunk sizes are important because what semantic vector database does is it will pick up 00:09:11.880 |
that chunk and convert that into, use the embedding model and convert that into a embedding vector 00:09:19.820 |
And it will, if you don't have an overlap, then the context between the previous and the next 00:09:25.000 |
chunk will be lost if there is any relationship. 00:09:27.260 |
So you try to be smart on how much overlap do I need between my previous chunk and the next 00:09:32.860 |
chunk and what is the size of the chunk that I should use when I'm chunking my documents 00:09:39.280 |
That is where the advantage of graph reg comes into play. 00:09:43.180 |
Because if you think about it, the important information, which is the relationship between 00:09:48.120 |
different entities are not exploited by your semantic vector database, but they are exploited 00:09:55.160 |
really well when you're trying to use a knowledge graph or create a knowledge graph based system. 00:10:02.280 |
So once you have created this knowledge graph, what is the next step? 00:10:06.280 |
Now comes the retrieval piece, which is you ask a question. 00:10:11.180 |
What is ExxonMobil's cut this quarter that it is looking like? 00:10:17.120 |
And knowledge graph will help you figure out how to retrieve those nodes or those entities and the relationship between them. 00:10:26.260 |
If you do a very flat retrieval, which is a single hop, you are missing the most important piece that graph allows you, which is exploitation through multiple nodes that you can think about. 00:10:47.000 |
Again, you would spend a lot of time to optimize this, whether you should look at single hop, double hop, how much deep you want to go so that nodes, the relationship between your first node to the second node, your second node to the third node is exploited pretty well. 00:11:01.000 |
And the more deeper you go, the better context you will get, but there's a disadvantage of that. 00:11:06.900 |
The more deeper you go, the more time you're going to spend on retrieving that information. 00:11:10.900 |
So then latency becomes a factor as well, especially when you're working in a production environment. 00:11:15.900 |
So there is a sweet spot that you have to hit when you're trying to go, how deep you want to go, how many hops you want to go into your graph versus what is the latency that you can survive. 00:11:32.800 |
And some of those searches can be accelerated. 00:11:35.800 |
So we created a library called cool graph, which is available or integrated in a lot of libraries out there, like network X and whatnot. 00:11:45.700 |
But that acceleration becomes important so that it gives you the flexibility to get deeper into your graph, both through multiple hops, but at the same time, you can reduce the latency. 00:11:55.700 |
So your performance of your graph improves a lot. 00:12:02.700 |
So this is where the retrieval piece comes into play, where you can have different strategies defined so that when you're querying your data and getting the responses, you can have better responses. 00:12:16.600 |
And the other important piece, I personally worked on this piece, so I can talk at length on this, but I'm going to give you a very high level, is evaluating the performance. 00:12:26.600 |
And there are multiple factors that you can evaluate on faithfulness, answer relevancy, precision recall, if you try to use an LLM model, helpfulness, correctiveness, coherence, complexity, verbosity, all these factors becomes very important. 00:12:40.500 |
So there's a library, so there's a library called RAGAS. 00:12:44.400 |
It is meant to evaluate your RAG workflow end to end. 00:12:49.400 |
Anyone who used RAGAS for evaluating your graph? 00:12:54.400 |
But it is an amazing library that you can use to evaluate your RAG pipeline end to end, because it evaluates the response, it evaluates the retrieval, and it evaluates what the query is. 00:13:06.400 |
So it will evaluate your pipeline end to end, which becomes very handy when you're trying to test whether my retrieval is doing the right thing or whether the question that I'm asking is the LLM interpreting it in the right way or not. 00:13:19.300 |
So you can break down your responses in the RAGAS pipeline, we evaluate all those pieces and see what your eventual score is. 00:13:29.300 |
The other is LLM, and RAGAS under the hood uses an LLM, no surprises there. 00:13:35.300 |
By default, it is integrated with GPT, but it provides you the flexibility that if you have your own model, you can bring it in as well, and you can wire it up with your API, and you can use that LLM to figure out on these four evaluation parameters that RAGAS offers. 00:13:56.300 |
So it's quite, I wouldn't say it's comprehensive, but it's really good in terms of giving you that flexibility. 00:14:02.300 |
The other part is using a model that is meant to evaluate specifically the response coming out of the LLM. 00:14:10.300 |
And that is where this model, Lama Nimotron 340 billion reward model that we released, I think, a few years ago. 00:14:15.300 |
At that time, it was a really good response model. 00:14:17.300 |
It's a 340 billion parameter model, so reasonably big, but it evaluates, it's a reward model. 00:14:24.300 |
So it will go and evaluate the response of another LLM and judge it in terms of how the responses are looking like on these five parameters. 00:14:42.300 |
So moving further, I would like to use this analogy that for, to create a graph right system, it will take you, which is 80% of the job, it will take you 20% of your time. 00:14:54.300 |
But then to make it better, which is the last 20%, sorry, which is the 80-20 rule, the last 20% will take 80% of your time. 00:15:05.300 |
Because now you are in the process of optimizing it further to make sure it works for the use case good enough for the application that you're working on. 00:15:16.300 |
And there are some strategies there which I would like to walk you through. 00:15:20.300 |
So one, as I said before, which I couldn't stress enough, the way you are creating your knowledge graph out of your unstructured data becomes very important. 00:15:28.300 |
The better your knowledge graph, the better results you're going to get. 00:15:32.300 |
And something that we did as experimentation through this use case that we were exploring with one of our partners, 00:15:39.300 |
was can we fine tune an LLM model to get the quality of the triplets that we are creating better? 00:15:50.300 |
Can we do a better job at data processing, like removing regex, apostrophes, brackets, words that, characters that don't matter? 00:15:58.300 |
If we remove them, does it give you better results? 00:16:01.300 |
So these are like small things that you can think about, but it gives you, it improves the performance of your overall system. 00:16:08.300 |
So that is where you, I'm talking about 80% of your time. 00:16:11.300 |
Small nitty-gritty of the things that you are, the knobs that you are fine tuning slowly and steadily to make sure your performance gets better and better. 00:16:20.300 |
And I would like to share a few strategies that we did, which we got, which led us to, which led us to get better results. 00:16:29.300 |
So the very first thing is Regex, or just cleaning out your data. 00:16:35.300 |
We removed apostrophes, other characters that are not that important, if you think about triplet generation. 00:16:49.300 |
We then implemented another strategy of reducing the, not missing out of longer output, making it smaller. 00:16:59.300 |
And we also fine tuned the LAMA 3.3 model or 3.2 model, and that got us better results. 00:17:05.300 |
So if you look at the last three columns, you'll see that by using LAMA 3.3 as is, we got 71% accuracy. 00:17:13.300 |
So this was tested on 100 triplets to see how it is performing. 00:17:21.300 |
So as it got better, and as we introduced LARA, we fine tuned the LAMA 3.1 model, our accuracy or performance went up from 71% to 87%. 00:17:31.300 |
And then we did those small tweaks, it improved the performance better. 00:17:34.300 |
Again, remember, there's 100 documents, so the accuracy is looking high, but if your document pool increases, that will come down a bit. 00:17:40.300 |
But in comparison to where we were before, we saw improvement. 00:17:43.300 |
And that is where the small tweaks come into play, which will be very, very, very helpful to you when you're putting a system, a graph reg or a reg system into production. 00:17:58.300 |
So if your graph gets bigger and bigger, now you're talking about a network which goes into millions or billions of parameters, or millions and billions of nodes. 00:18:08.300 |
Now, how do you, how do you do search in those millions and billions, in the graph that has got millions or billions of nodes? 00:18:18.300 |
And that is where acceleration comes into play. 00:18:20.300 |
So with Coograph, which is now available through NetworkX, so NetworkX is also a pip install library. 00:18:36.300 |
And if you see a few of the algorithms, we did a performance test on that. 00:18:42.300 |
And you can see the amount of latency in terms of overall execution and reducing drastically. 00:18:48.300 |
So that is where you can, again, small tweaks, which will lead you to better results. 00:18:53.300 |
So these are two things that we experimented, which led us to better results in terms of accuracy, as well as reducing the overall latency. 00:19:00.300 |
And these are small tweaks, and it leads us to better results. 00:19:07.300 |
So then the question, obviously, is should I use graph, or should I use semantic base drag system, or should I use hybrid? 00:19:15.300 |
And I'm going to give you the diplomatic answer. 00:19:18.300 |
But there are a few things I would like you guys to take home, which will help you to come up to a decision. 00:19:26.300 |
So that you can make an educated guess that for this use case that I'm working on, a drag system would solve the problem, I don't need a graph, and vice versa. 00:19:39.300 |
Traditionally, if you look at retail data, if you look at FSI data, if you look at employee database of companies, those have a really good structure defined. 00:19:48.300 |
So those kind of data set becomes really good use cases for graph-based system. 00:19:55.300 |
And the other thing you think about is even if you have unstructured data, can you create a good graph, a knowledge graph out of it? 00:20:02.300 |
If the answer is yes, then it's worthwhile experimenting to go the graph path. 00:20:09.300 |
And it will depend on the application and use case. 00:20:12.300 |
So if your use case requires to understand the complex relationship and then extract that information for the questions that you are asking, only then it makes sense to use graph-based. 00:20:25.300 |
Because remember, these are compute-heavy systems. 00:20:28.300 |
So you need to make sure that these things are taken care of. 00:20:33.300 |
But as I said before, all these things that I talked about, I gave you a 10,000-feet view. 00:20:38.300 |
If you want to get a 100-feet view where you are coding into things, all these things is available on GitHub. 00:20:43.300 |
Even the fine-tuning of the LAMA 1.1 LoRa model. 00:20:48.300 |
So I gave you a 20-minute talk, but this whole workshop is covered in two hours as well. 00:20:55.300 |
We do release all these things on a regular basis. 00:20:58.300 |
If you join the mailing list, you get this information based on your interest. 00:21:02.300 |
And as my colleague mentioned, I will be across the hall at Neo4j booth to answer questions if any. 00:21:09.300 |
I would love to interact with you and see if you have any questions and I can answer those questions. 00:21:33.300 |
And if I get this right, you're going to take a philosophical perspective on this. 00:22:45.340 |
okay so i don't know if there's a way to get speaker notes onto the screens at the bottom you guys know 00:23:02.780 |
yes you have to go on full screen do you need the notes yeah i need the notes 00:23:12.540 |
i see the mode you can also just walk through it on the side and just 00:23:17.180 |
yeah sure like that can you collapse this side 00:23:20.940 |
yeah yeah okay so hi hi everybody uh my name is chink young lamb um i'm a founder and CEO of patho.ai 00:23:37.660 |
uh a bit of background by my company uh patho.ai started two years ago with an invitation from 00:23:43.340 |
national science foundation from the spir grant funding investigating lm bird we did a lm bird 00:23:50.940 |
driven discovery application uh since then we branch out to leverage what we learned about building ai 00:23:57.660 |
system for large corporation we are currently building expert ai system for several clients currently the 00:24:04.700 |
system we build goes beyond rack system um many of our clients is asking for ai system that perform 00:24:11.580 |
tasks like a research and advisory role based on their area of interest uh today the talk is about 00:24:18.940 |
sharing with our fellow ai engineer what we learned so far within this kind of system 00:24:24.300 |
okay uh what is knowledge okay generally philosophically i say knowledge is the understanding 00:24:29.660 |
and awareness gained through experience education and a comprehension of facts and principle 00:24:34.300 |
and that lead to the next question is what is knowledge graph right so knowledge graph is a systematic 00:24:41.500 |
method of preserving wisdom by connecting them and creating a network or interconnect relationship that's 00:24:47.500 |
important the graph represents the thought process and comprehensive taxonomy of a specific domain of expertise 00:24:55.980 |
that's why this is very important for people moving forward it's about ai system then think a lot and return 00:25:03.340 |
advice instead of just retrieves you know data from your database right so that comes to the development of this uh 00:25:11.340 |
k-a-g okay what is k-a-g k-a-g stands for knowledge augment generations and it's different from rack okay 00:25:18.220 |
it is enhanced language model by integrating structure knowledge graph for more accurate and insightful response 00:25:25.180 |
making it smarter more structure approach than a simple rack k-a-g doesn't just retrieve 00:25:32.860 |
remember you understand this is different okay after interviewing a lot of my client okay so we also 00:25:42.220 |
expert in a certain area of scale i found that there are common ways of their thinking decision making 00:25:48.380 |
process the way that make them expert in their area knowledge graph seems to be a perfect repeat 00:25:53.820 |
so here is the graph or state diagram if you are computer engineering grad like me so um it shows a wisdom 00:26:02.140 |
the form the for the wisdom note as you can see is that it's a core right this wisdom it just 00:26:09.660 |
isn't static it actively guide decision and views by other element 00:26:15.260 |
the output from the wisdom actually goes to decision making in the blue right wisdom isn't passive it guide 00:26:25.260 |
decision helping us choose wisely okay and then the decision making analyze the situation 00:26:32.060 |
given in the circle in the circle in the green and decision on make you know in a vacuum okay they 00:26:40.460 |
analyze real world situation that's the difference okay so look at the wisdom input okay look at the 00:26:46.540 |
relationship feedback from the knowledge to wisdom in gold color example of that is knowledge to wisdom 00:26:54.540 |
like all your book smart and encyclopedia wikipedia whatever you store plus once that data get absorbed 00:27:05.420 |
by our whatever model you use up there it need to regurgitate that and understand that's why it's very 00:27:11.100 |
important that wisdom is able to synthesize the data after you ingested knowledge you know that's the kind of 00:27:16.460 |
abstract but i'll come to that later how about i'm talking about okay okay from inside example of that is 00:27:22.460 |
wisdom derived pattern from chaos right some of my client has a lot of social media their product how 00:27:30.300 |
do they you know track their product settlement from from social media right so it's very chaotic and from x 00:27:36.380 |
tweet right so so from that you can see some pattern of their competitor versus uh current what my product 00:27:42.060 |
is that that is like an example of that and i will go to that later okay when all these connected nodes matter 00:27:49.420 |
together why do they matter all the nodes relate to one another to ever increase enriching our wisdom 00:27:57.100 |
storing system okay this talk is about storing wisdom right so knowledge tells you what it is right and 00:28:04.540 |
experience tell you what worked before inside invent what to try next right like a pizza knowledge is 00:28:15.500 |
recipe experience is knowing your oven burnt crust inside is like hey it is adding you know honey to 00:28:24.860 |
the crust you make caramelized perfectly right so the most important part of the knowledge graph is 00:28:30.460 |
feedback loop okay feedback isn't one way street it learn from itself look at the feedback from the 00:28:37.340 |
going back going back to all the note from inside to wisdom okay um situation informs future wisdom 00:28:45.020 |
experience deepen it inside sharpen it like a tree growing roots the more effect the stronger it gets 00:28:53.580 |
now now i want to ask you a question in general where do you see this circle in your life maybe a tough 00:29:00.380 |
decision that you know taught you something so one practical application for leadership is wisdom avoid knee jack 00:29:10.860 |
reaction by learning from feedback as for personal growth ever notice how past mistakes make you wiser 00:29:18.140 |
that's the loop in the action all this so the takeaway from the slide in this is wisdom isn't 00:29:25.820 |
a trophy you earn it is the muscle you exercise the more you feed knowledge experience insight the more 00:29:33.660 |
they guide you now i will show you how it being mapped to my current client you know all this is like very 00:29:41.900 |
abstract right so hi one of my clients actually doing a competitive analysis uh they used to have a 00:29:48.380 |
marketing department doing that but they want ai to do that right they asked me to build the system 00:29:53.900 |
this is exactly what i did with the same taxonomy of storing all this so this talk taxonomy will be 00:30:00.140 |
later on i talk about how multi-agents going to handle all that here is one of the chatbot that i 00:30:06.220 |
build for my client to do you know not just some we not just some cap okay it's our wisdom graph power ai 00:30:14.460 |
designed to turn data in the strategy right dominant so what kind of question i talk about how do i win 00:30:19.980 |
my competitor in this market space that's kind of a very sophisticated question right so without uh if 00:30:24.860 |
you do simply just write my first speaker talk about right right so it's not going to cut it they're not 00:30:29.980 |
going to able to answer that kind of question okay what i did is this uh we retained the same taxonomy and 00:30:35.580 |
the wisdom is then mapped the same engine there the wisdom engine this engine is like an orchestration 00:30:41.180 |
agent that does a lot of decision making including advising what the arms able to see based on the 00:30:47.580 |
current situation what to do next right so um what i did is uh for the uh decision making i map it to 00:30:55.420 |
a strategy generator so these customers are talking about a competitive analysis right so um i map the 00:31:00.700 |
knowledge in term of knowledge what do they have they have market data right so i 00:31:05.500 |
map this experience to hp is one of a kind past campaign so they have a lot of campaign doing a 00:31:13.260 |
lot of marketing and then um the inside is actually mapped to uh in industrial insight so they have a 00:31:20.300 |
database doing storing that and then of course the most important is is the situation the situation is 00:31:27.020 |
how how am i doing how my product selling right so so that that is like a situation and then i map that to a 00:31:33.740 |
a competitor witness that means they say if you make the lm aware of that you probably get a very good 00:31:41.260 |
answer and then you know the chatbot will probably be doing the right thing advising so from here very 00:31:47.500 |
high level you know state diagram or that how do i map it to a system that drive well here comes the trick so 00:31:55.180 |
so anybody here heard of any all right all right all right so so so i i first encounter similar situation 00:32:02.940 |
when i passed iot project which is not great developed by uh ibm right so it's the same kind of thing it's 00:32:09.820 |
like no code but but underneath the hood there's a bunch of code okay it's all node.js code okay so uh but 00:32:15.820 |
but for the for for proving your concept and all that it's very very very flexible and i right highly recommend 00:32:21.820 |
that and and and here here you can take a look at the the workflow the break from i enable the 00:32:26.860 |
implementation of this complicated state diagram with um what i say is there is a different community 00:32:33.420 |
you know one of the very powerful node is the ai agent well previously nann is just workflow automation 00:32:38.620 |
too i'm not selling for anything i'm just telling you i'm using it uh for prototyping uh further down 00:32:44.380 |
the road maybe the client say us too like i i really need to you know go is now have the option 00:32:50.140 |
to drive uh different model like open ai model and tropic model and even on-prem model and then that 00:32:56.220 |
the key in making the stick the same machine work is that move out in a graph rag track why are we talking 00:33:01.900 |
about fusion and decoder well i'm glad you asked because the next big breakthrough was knowledge graph with 00:33:06.780 |
fusion and decoder so you can use knowledge graphs with fusion and decoder uh as a technique and this sort of 00:33:13.100 |
improves upon the fusion and decoder paper by using knowledge graphs to understand the relationships 00:33:18.620 |
between the retrieved passages and so it helps with this efficiency bottleneck and improves uh the process 00:33:25.580 |
i'm not going to walk through this diagram step by step but this is the diagram in the paper of the 00:33:29.260 |
architecture where it uses the graph and then does this kind of two-stage re-ranking of the passages and 00:33:35.340 |
it helps with uh improving the efficiency while also lowering the cost and so the team took all this 00:33:40.700 |
research and came to get came together to build their own implementation of fusion and decoder since 00:33:45.420 |
we actually build our own models uh to make that kind of the final piece of the puzzle and it really 00:33:50.860 |
helped our hallucination rate it really drove it down and then we published a white paper with our own 00:33:55.180 |
findings of it and so then we kind of had that piece of the puzzle and there's a few other techniques 00:34:00.460 |
that we don't have time to go over but point being we're assembling together multiple techniques based on 00:34:05.820 |
research to get the best results we can for our customers so that's all well and good but like 00:34:10.860 |
does it actually work like that's the important part right so we did some benchmarking last year we 00:34:15.180 |
used amazon's robust qa data set and compared our retrieval system with knowledge graph and fusion 00:34:20.780 |
decoder and everything uh with our with seven different vector search uh systems and we found 00:34:27.740 |
that we had the the best accuracy and the fastest response time so encourage you to check that out and 00:34:32.860 |
kind of check out this process benchmarks are really cool but what's even cooler is like what it unlocks 00:34:38.700 |
for our customers which are various features in the product um for one because like most draft 00:34:45.580 |
structures we can actually expose the thought process because we have that relationships and the additional 00:34:51.260 |
context where you can show the snippets and the sub queries and the sources for how the rag system is 00:34:56.940 |
actually getting the answers and we can expose this in the api to developers as well as in the product 00:35:01.900 |
and then we're also to have able to have knowledge graphics sell at multi-hop questions where we can 00:35:08.060 |
reason across multiple documents and multiple topics without any struggles and then lastly it can handle 00:35:15.740 |
complex data formats where vector retrieval struggles where an answer might be split into multiple pages 00:35:21.500 |
or maybe there's a similar term that doesn't quite match what the user is looking for but because we have that 00:35:27.340 |
graph structure and and the and fusion and decoder with the additional context and relationships we're 00:35:31.980 |
able to uh formulate these correct answers so again my main takeaway here is that there are many ways that 00:35:40.300 |
you can get the benefits of knowledge graphs in rag that could be through a graph database it could be 00:35:45.340 |
through doing something creative with posters it could be through a search engine uh but you can 00:35:49.820 |
you take advantage of the relationships that you can build with knowledge graphs uh in your rag system 00:35:55.980 |
and as you get there you can challenge your assumptions and focus on the customers to be 00:35:59.900 |
able to get to the end result to to make the team successful and so for our team it was focusing on the 00:36:05.020 |
customer needs instead of what was hyped staying flexible based on the expertise of the team and letting 00:36:11.020 |
research challenge their assumptions um so if you want to join this amazing team we're hiring across 00:36:16.780 |
research engineering and products uh we would love to talk to you about any of our open roles and i'm 00:36:21.900 |
available for questions you can come find me in the hallway or reach out to me on twitter or linkedin 00:36:27.340 |
and that's all i've got for you thank you so much 00:37:10.300 |
can you hear me now there i am lies on okay in the giant umbrella 00:37:38.580 |
In the giant umbrella that is Graphrag, there are many techniques, many approaches, many ways 00:37:43.680 |
that get things done, there's knowledge graph construction, there's retrieval, but then 00:37:48.620 |
there's the notion of going post-rag and thinking about different ways of thinking about what 00:37:53.700 |
knowledge is, what we're actually doing in the first place. 00:37:56.920 |
So next up is my good friend Daniel from Zapp to lead us through that. 00:38:22.620 |
Thank you, Andrea, Andreas, as well, for the intro. 00:38:26.020 |
I'm Daniel, the founder of Zapp AI, and we build memory infrastructure for AI agents. 00:38:32.900 |
And I'm going to tell you that you're doing memory all wrong. 00:38:38.420 |
Well, it may not be you directly, but it may be the framework that you're using to build 00:38:43.980 |
I also think that knowledge graphs are awesome. 00:38:50.740 |
And you should be using them for agent memory, not just for Graphrag. 00:38:57.740 |
So before I dive into expanding on my hot takes, I want to touch on why memory is so important. 00:39:03.340 |
So we're routinely building agents that forget important context about our users. 00:39:09.440 |
All that dynamic data that we're gathering from conversations between the agent and the 00:39:14.800 |
user, all the data, business data from our applications, line of business applications, 00:39:20.180 |
et cetera, there's so much richness about who the user is, and yet we're not enabling our 00:39:26.800 |
And our agents respond as a result generically or hallucinate even worse. 00:39:32.540 |
And this definitely isn't the path to AGI, or more concretely, retaining our customers. 00:39:40.760 |
So memory isn't about semantically similar content. 00:39:46.340 |
And when I talk about RAG here, I'm primarily talking about vector database-based RAG, not 00:39:56.060 |
But consider the stylized example where we have learned a brand preference for Adidas shoes. 00:40:01.420 |
And unfortunately, Robbie's Adidas shoes fall apart, so he's rather unhappy. 00:40:09.820 |
However, Robbie's follow-up question to the agent, where he asked what sneakers he should 00:40:16.980 |
purchase, is most similar to the first Adidas fact. 00:40:21.580 |
And so if we're using a vector database, that fact may be at the top of the search results, 00:40:29.500 |
So when using RAG, each fact is an isolated and immutable piece of content. 00:40:39.300 |
The three facts on the left exist with no understanding of causality. 00:40:45.620 |
Semantic search can't reason with the why things change over time. 00:40:51.940 |
And this is why RAG approaches fail as memory. 00:40:55.480 |
RAG lacks a native temporal and relational reasoning. 00:41:01.580 |
And none of this should be a surprise under the hood. 00:41:04.640 |
We're just working with similarity in an abstract space. 00:41:08.060 |
There's no explicit relationships between these embeddings, these vector representations 00:41:13.140 |
of the facts that we've generated for our memory. 00:41:18.260 |
However, when we look at knowledge graphs, we can define explicit relationships. 00:41:24.100 |
Graphs can model the why, and at Zepp, we've got them to model the when as well, behind the 00:41:30.780 |
preference change, which adds a temporal dimension that your agent can reason over. 00:41:37.040 |
And this structural difference is fundamental to how memory should work. 00:41:45.780 |
Graffiti is Zepp's open source framework for building real-time, dynamic temporal graphs. 00:41:55.200 |
Graffiti is temporally aware and graph relational. 00:42:01.080 |
You can find it on GitHub, go to git.new forward slash graffiti. 00:42:05.620 |
It has 10,000 plus stars, almost 11,000 quadrupled within the last six weeks. 00:42:12.700 |
So thank you, everybody, who's dried out graffiti and loved it. 00:42:15.540 |
So let's dive into how each of these attributes of graffiti works. 00:42:24.320 |
Graffiti extracts and tracks multiple temporal dimensions for each fact. 00:42:30.520 |
It identified when a fact is valid and becomes invalid. 00:42:35.880 |
On the right-hand side, you can see how, when we're using the example that I illustrated 00:42:42.820 |
a few slides back, how graffiti would pause those different time frames. 00:42:55.080 |
And it can answer questions that RAG simply cannot handle. 00:42:58.420 |
Or it enables your agent to answer questions that RAG simply cannot handle. 00:43:06.160 |
And so when we look at what RAG can do, we actually sit with a bunch of contradictory embeddings 00:43:19.460 |
So if we're updating the brand preference, we'll have a new brand preference fact in the vector database. 00:43:30.080 |
However, graffiti understands that broken shoes invalidate the love relationship, 00:43:35.240 |
which creates a causal relationship between those three events in the previous slide. 00:43:40.960 |
Broken shoes result in disappointment, which results in a brand preference change. 00:43:49.500 |
Graffiti doesn't delete the history of facts as they change, as they're invalidated, but marks them invalid, rather. 00:43:58.240 |
And so we store a sequence of state changes on the graph, which allows your agent to then reason with those state changes over time. 00:44:09.680 |
So for example, the next time I come back to the e-commerce agent to purchase shoes is not going to recommend the Adidas shoes to me. 00:44:18.400 |
And here's the resulting graph, a closer approximation to how humans might process and recall changing state over time. 00:44:29.740 |
On the graph, we can see that the existing Adidas brand preference is still there, but it hasn't expired that date. 00:44:39.780 |
We also see that there's a new brand preference for Puma shoes, which is valid, and it doesn't have an invalid that date. 00:44:59.140 |
Graffiti uses semantic search and BM25 full-text retrieval to identify sub-graphs within the broader graffiti graph. 00:45:08.960 |
And these can be traversed using graph traversal techniques to develop a richer understanding of memory. 00:45:17.200 |
So we can find adjacent facts that might fill out the agent's understanding of memory. 00:45:24.060 |
And the results are then each fused together. 00:45:28.420 |
And so this offers a very fast, accurate retrieval approach. 00:45:33.200 |
And graffiti has a number of different search recipes built into it. 00:45:37.760 |
So you can really explore how to take different approaches to retrieving data for your particular agent. 00:45:50.960 |
When we look at recent changes that we've added to graffiti, we allow developers now to model their business domain on the graph. 00:46:01.260 |
Because a mental health application will have very different types of things it needs to store and recall from memory to an e-commerce agent. 00:46:12.100 |
And so graffiti allows you to build constructs, custom entities, and edges that represent the business objects within your particular business or application. 00:46:27.180 |
And so here we have an example of a media preference where we've been learning all about a user's preferred podcasts and music. 00:46:39.660 |
And we have defined an actual structure here for media preference. 00:46:44.340 |
And what this does is it allows us to then also retrieve, explicitly retrieve, media preferences from the graph, rather than a bunch of other noise that we might have added to memory. 00:46:58.320 |
And this ontology really enables you to bring a lot of depth to how memory operates. 00:47:07.280 |
So I'm not advocating that you replace RAG everywhere. 00:47:11.860 |
RAG, graph RAG, the various forms of graph RAG, and graffiti, each has its strengths and ideal use cases. 00:47:23.620 |
Graffiti is really strong when you're wanting to integrate incrementally dynamic data into a graph without significant recomputation. 00:47:34.160 |
It's really strong when you want to model your business domain. 00:47:37.860 |
It's strong where it has very low latency retrieval. 00:47:43.540 |
If you've tried graph RAGs, they often have an LLM in the path incrementally summarizing the output from the graph. 00:47:52.900 |
Graffiti operates in under hundreds of milliseconds. 00:47:57.000 |
And so the key is recognizing which solution offers to your business, what it offers to your business. 00:48:06.100 |
And most agentic applications could use RAG, a RAG approach, and graffiti. 00:48:14.360 |
So just summing it all up, agent memory is not about knowledge retrieval. 00:48:19.180 |
Temporal and relational reasoning is so critical to coherent memory. 00:48:27.520 |
We need to understand how something like preferences or user traits might change over time. 00:48:35.100 |
And that's something that contemporary RAG solutions lack. 00:48:41.480 |
So we published a paper earlier this year describing ZEPP's use of graffiti. 00:48:47.900 |
And it's a deep dive into the graffiti architecture and how ZEPP performs as a consequence of using graffiti under the hood. 00:48:55.660 |
So you can follow the link below to land at the archive preprint if you'd like to take a look. 00:49:00.600 |
And I'm sure the slides will be available after the talk, so you can go to the paper. 00:49:10.460 |
ZEPP goes beyond simple agent memory to build a unified customer record derived from both chat history and business data. 00:49:20.720 |
So you can stream in user chat conversations, but also stream in business data from your SaaS application, from line of business applications like CRM or billing systems. 00:49:31.820 |
And it builds this unified, holistic view of the user, really enabling your agent to have an accurate and very comprehensive real-time understanding of the user so it can solve complex problems for that user. 00:49:48.560 |
So stick around for the agent memory lunch and learn, which is the next session. 00:49:56.020 |
And in it, amongst other folks, I'll be demoing ZEPP's approach to domain-specific memory, built on graffiti's custom entities and edges. 00:50:09.000 |
We have a few minutes, so I'm happy to answer questions. 00:50:22.000 |
The question was, do you need to use ZEPP to use graffiti? 00:50:41.680 |
So our partners, Neo4j, can assist you with a community edition install. 00:50:46.380 |
And strongly recommend their desktop product. 00:50:56.000 |
So underneath the hood, how do you invalidate graph edges? 00:51:16.320 |
So graffiti makes extensive use of LLMs to intelligently parse incoming data, which could be unstructured or structured. 00:51:27.520 |
So the unstructured conversation, unstructured emails, structured data in JSON format, and fuse it together on the graph. 00:51:37.220 |
And as part of integrating, we're using LLMs to identify, in a pipeline, identify conflicting facts. 00:51:45.880 |
And so that's where we get this ability to go from broken shoes to disappointment to a switch in brand preferences. 00:51:56.540 |
So the LLMs is able to understand emotional valence of the events that it is seeing. 00:52:22.620 |
So the question was, how do we handle revalidation of facts if a state flips back to a prior state? 00:52:33.660 |
A new edge might be created that represents a success of fact. 00:52:58.020 |
So why can graffiti do real-time updates but Microsoft GraphRag cannot? 00:53:03.220 |
So micro GraphRag is, an oversimplification, is summarizing document chunks or documents at many different levels. 00:53:15.400 |
And creating repeated summarizations at different levels. 00:53:18.380 |
So a summary of the summaries of the summaries, et cetera. 00:53:24.420 |
So if any of the underlying data changes, you're ending up with a cascading number of summarizations. 00:53:33.800 |
Graffiti is designed to identify specific nodes and edges that are implicated in an update. 00:53:44.960 |
And then is able to invalidate with a surgical precision the edges that are implicated in the conflict. 00:53:56.360 |
Or we just add new edges or nodes into the graph where it's relevant. 00:54:05.120 |
And so we're able to use a variety of search pipelines as well as a number of different heuristics to really make very focused changes in the graph, which are lightweight and cheap. 00:54:31.020 |
So there are two ways that graffiti operates. 00:54:36.660 |
The first, last question, the first one is that graffiti will build the ontology for you and will very carefully try to deduplicate edge and node types. 00:54:50.820 |
Secondly, as I mentioned a little bit earlier, we allow you to define an ontology using Pydantic, Zod, Go structs, et cetera. 00:55:07.420 |
And as Daniel mentioned, there's lunch being served outside right now, actually. 00:55:15.500 |
So I encourage you all to go get a bite to eat. 00:55:19.740 |
We're going to have a panel discussion about overall agentic memory, different implementations of it. 00:55:24.780 |
And you're going to be part of that panel as well, right? 00:55:27.720 |
So come back at 1 o'clock for a longer session of day, gentle memory. 00:55:36.180 |
Are there any limitations when it comes to the data set, graffiti can handle? 00:56:36.580 |
She's overdoing that, and I'm overdoing that, and I'm overdoing that situation. 00:58:05.920 |
Check, check, check, check, check, check, check, check, check, one, two. 01:21:21.380 |
Can we do a test for all of us before we head to the stage? 01:22:05.380 |
I think I need like five minutes if we have three minutes. 01:23:23.380 |
He said something about mirroring your screen up there, so we have to, like, set that up. 01:23:42.380 |
You could actually tell that to Daniel and Vasilija just in case. 01:23:46.380 |
So that there is no, I mean, there are always glitches, but less of them. 01:24:04.380 |
Once you get up there, you're going to get there. 01:24:32.380 |
Once you get up there, you're going to cut that from five. 01:24:48.380 |
This is the musical section of the afternoon. 01:24:55.380 |
And I should remember myself, but I've told the other speakers to stay here in the middle 01:25:01.380 |
For the lunch and learn, we have the great treat that my good friend, Mark Bain, Mark, who's 01:25:06.380 |
over there, Mark, who's going to be taking us through agentic memory, doing a kind of a broad 01:25:12.380 |
sweep, like, you know, dive into agentic memory, but then we're also going to have a panel discussion 01:25:17.380 |
This is going to be a longer session than the rest of the graph rag track. 01:25:42.380 |
This is my first time speaking at AI Engineer. 01:25:47.380 |
And we have an amazing group of speakers, guest speakers. 01:26:12.380 |
I will do a very quick power talk about the topic that I'm super passionate. 01:26:23.380 |
And we'll move on to some new solution that we are proposing. 01:26:28.380 |
A GraphRack chat arena that I will be able to demonstrate. 01:26:33.380 |
And I would like you to follow along once it's being demonstrated. 01:26:40.380 |
And at the very end, we'll have a very short Q&A session. 01:26:47.380 |
There is a Slack channel that I would like you to join. 01:26:52.380 |
So, please scan the QR code right now before we begin. 01:26:57.380 |
And let's make sure that everyone has access to this material. 01:27:02.380 |
There is a walkthrough shirt on the channel that will go through closer to the end of our workshop. 01:27:13.380 |
But I would like you to start setting it up, if you may, on your laptops if you want to follow along. 01:27:49.380 |
And applications of memory across different technologies. 01:27:54.380 |
You can find me at Mark and Bain on social media or on my website. 01:27:59.380 |
And let me tell you a little bit of a story about myself. 01:28:06.380 |
So, when I was 16 years old, I was very good at maths. 01:28:11.380 |
And I did math olympiads with many brilliant minds, including Wojciech Zaremba, the co-founder of OpenAI. 01:28:19.380 |
And thanks to that deep understanding of maths and physics, I did have many great opportunities to be exposed to the problem of AI memory. 01:28:33.380 |
So, first of all, I would like to recall two conversations that I had with Wojciech and Ilya in 2014 in September. 01:28:45.380 |
When I came here to study at Stanford, at one party, we met with Ilya and Wojciech, who back then worked at Google. 01:28:55.380 |
And they were kind of trying to pitch me that there will be a huge revolution in AI. 01:29:06.380 |
Right now, I probably kind of take it as a very big excitement when I look back to the times. 01:29:14.380 |
And I was really wishing good luck to the guys who were doing deep learning. 01:29:20.380 |
Because back then, I didn't really see this prospect of GPUs giving that huge edge in compute. 01:29:29.380 |
And so, during that conversation, it was like 20 minutes. 01:29:34.380 |
At the very end, I asked Ilya, all right, so there is going to be a big AI revolution. 01:29:42.380 |
But how will these AI systems communicate with each other? 01:29:48.380 |
And the answer was very perplexing and kind of sets the stage to what's happening right now. 01:30:06.380 |
The last two years, I've spent doing very deep research on physics of AI. 01:30:12.380 |
And kind of like delve into all of these most modern AI architectures. 01:30:18.380 |
Including attention, diffusion models, VAEs, and many other ones. 01:30:23.380 |
And I realized that there is something critical. 01:30:31.380 |
And this power talk is about this missing thing. 01:30:35.380 |
So, over the last two years, I kind of followed on on my last years of doing a lot of research 01:30:46.380 |
in physics, computer science, information science. 01:30:49.380 |
And I came to this conclusion that memory, AI memory, in fact, is any data in any format. 01:31:02.380 |
Including code, algorithms, and hardware, and any causal changes that affect them. 01:31:12.380 |
That was something very mind-blowing to reach that conclusion. 01:31:16.380 |
And that conclusion sets the tone to this whole track. 01:31:26.380 |
In fact, I was also perplexed by how biological systems use memory. 01:31:33.380 |
And how different cosmological structures or quantum structures, they, in fact, have a memory. 01:31:50.380 |
When I was doing science olympiads, I was really focused on two, three things. 01:31:58.380 |
And I realized in the last year that more or less the volume of loss in physics perfectly matches the volume of loss in mathematics. 01:32:16.380 |
If you really think deeply through geometry, they match the constants both in mathematics and in physics. 01:32:23.380 |
And if you really think even deeper, they kind of like transcend over all the other disciplines. 01:32:36.380 |
And I found out that the principles that govern LLMs are the exact same principles that govern neuroscience. 01:32:48.380 |
And they are the exact same principles that govern mathematics. 01:33:01.380 |
Perlman is this mathematician who refused to take a $1 million award for proving the... 01:33:23.380 |
And once I realized that this deep math of... 01:33:31.380 |
spheres and circles is very much linked with how attention and diffusion models work. 01:33:43.380 |
Basically the formulas that Perlman reached are linking entropy with curvature. 01:33:53.380 |
And curvature, basically if you think of curvature, it's attention. 01:33:58.380 |
So in a sense there are multiple disciplines where the same things are appearing multiple 01:34:07.380 |
And I will be publishing a series of papers with some amazing supervisors who are co-authors 01:34:28.380 |
And I came to this realization that this equation governs everything. 01:34:45.380 |
I came to this equation that memory times compute would like to be a squared imaginary unit circle. 01:35:00.380 |
If that existed ever, we would have perfect symmetries and we would kind of not exist. 01:35:07.380 |
because for us to exist, this asymmetries needs to show up. 01:35:11.380 |
And in a sense, every single LLM through weights and biases, the weights are giving the structure. 01:35:20.380 |
The compute that comes and transforms the data in sort of the raw format, the compute turns 01:35:29.380 |
The weights are basically, if you take these billions of parameters, the weights are the 01:35:34.380 |
sort of like matrix structure of how this data looks like when you really find relationships 01:35:44.380 |
And then there are these biases, these tiny shifts that are kind of like trying to like 01:35:50.380 |
in a robust way adapt to this model so that it doesn't break apart but still is... 01:36:02.380 |
So when we take weights and biases and we apply scaling laws and we keep adding more data, more 01:36:07.380 |
compute, we kind of get a better and better and better understanding of the reality. 01:36:12.380 |
In a sense, if we had infinite data, we wouldn't have any biases. 01:36:18.380 |
And this understanding is, again, the principle of this track, of GraphRack. 01:36:27.380 |
The disappearance of biases is what we are looking for when we are scaling our models. 01:36:34.380 |
So in a sense, the amount of memory and compute should be exactly the same. 01:36:40.380 |
It's just slightly expressed in a different way. 01:36:46.380 |
There are any imbalances, then something important happens. 01:36:53.380 |
And I came to another conclusion that our universe is basically a network database. 01:36:59.380 |
It has a graph structure and it's a temporal structure. 01:37:03.380 |
So it keeps on moving, following some certain principles and rules. 01:37:09.380 |
And these principles and rules are not necessarily fuzzy. 01:37:16.380 |
They have to be fuzzy because otherwise everything would be completely predictable. 01:37:24.380 |
But if it would be completely predictable, it means that me, myself, would know everything 01:37:30.380 |
about every single of you, about myself from the past and myself from the future. 01:37:37.380 |
And that's why we have this sort of like heat diffusion entropy models. 01:37:48.380 |
Any single asymmetry that happens at the quantum level, any single tiny asymmetry that happens 01:38:08.380 |
And these causal links are the exact thing that I would like you to have as a takeaway from this workshop. 01:38:20.380 |
The difference between simple RAC, hybrid RAC, any types of RAC, and graph RAC, 01:38:27.380 |
is that we are having the ability to keep these causal links in our memory systems. 01:38:36.380 |
Basically, the relationships are what preserves causality. 01:38:46.380 |
That's why we can optimize hypothesis generation and testing. 01:38:56.380 |
So we will be able to do amazing research in biosciences, chemical sciences, 01:39:04.380 |
just because of understanding that this causality is preserved within the relationships. 01:39:11.380 |
And these relationships, when there are these asymmetries that are needed, 01:39:16.380 |
they kind of create this curvature, I would say. 01:39:21.380 |
So we intuitively feel every single of you is choosing some specific workshops and talks that you guys go to. 01:39:31.380 |
Right now, all of you are attending to the talk and workshop that we are giving. 01:39:46.380 |
And this value, this information, is transcended through space and time. 01:39:51.380 |
It's very subjective to you or any other object. 01:39:56.380 |
And I think we really need to understand this. 01:40:04.380 |
So LLMs are basically these weights and biases or correlations. 01:40:12.380 |
You know, actually one thing that I learned from Wojciech 10, 8, 11 years ago was that hallucinations are the exact necessary thing to be able to solve a problem where you have too little memory or too little compute for the combinatorial space of the problem you are solving. 01:40:36.380 |
We are taking some hypothesis based on your history and you are kind of trying to project it into the future. 01:40:42.380 |
But you have too little memory, too little compute to do that. 01:40:45.380 |
So you can be as good as the amount of memory and compute you have. 01:40:48.380 |
So it means that the missing part is something that you kind of can curve thanks to all of these causal relationships and this fuzziness. 01:41:01.380 |
And reasoning is reading of these asymmetries and the causal links. 01:41:13.380 |
Hence, I really believe that agentic systems are sort of the next big thing right now because they are following the network database principle. 01:41:29.380 |
But to be causal, to recover this causality from our fuzziness, we need graph databases. 01:41:41.380 |
And that's the major thing in this emerging trend of GraphRack that we are here to talk about. 01:41:51.380 |
And I would like to, at this moment, invite on stage our three amazing guest speakers. 01:42:15.380 |
So Vasilje will show us how to search and optimize memory based on certain use case at hand. 01:42:52.380 |
I'm originally from Montenegro, a small country in the Balkans. 01:42:56.380 |
So if you want to go there, my cousins Igor and Miloš are going to welcome you. 01:43:01.380 |
So, you know, if in case you're just curious about memory, I'm building a memory tool on top 01:43:10.380 |
My background's in business, big data engineering and clinical psychology. 01:43:14.380 |
So a lot what Mark talked about kind of connects to that. 01:43:20.380 |
The demo is to do a Mexican standoff between two developers where we are analyzing their 01:43:26.380 |
And these data from the GitHub depositories is in the graph. 01:43:31.380 |
And these Mexican standoff means that we will let the crew of agents go analyze, look 01:43:37.380 |
at their data and try to compare them against each other and give us a result that should 01:43:41.380 |
represent who should we hire, let's say, ideally out of these two people. 01:43:46.380 |
So what we're seeing here currently is how Cognify works in the background. 01:43:50.380 |
So Cognify is working by adding some data, turning that into a semantic graph, and then we can 01:43:58.380 |
We plugged in crew AI on top of it so we can pretty much do this on the fly. 01:44:01.380 |
So here in the background I have a client running. 01:44:07.380 |
So it's now currently searching the data sets and starting to build the graphs. 01:44:16.380 |
But in the background we are effectively ingesting the GitHub data from the GitHub API, 01:44:23.380 |
building the semantic structure, and then letting the agents actually search it and make decisions on top of it. 01:44:29.380 |
So every time with live demos things might go wrong. 01:44:45.380 |
And as you can see we have activity log where the graph is being continuously updated on the fly. 01:44:53.380 |
And then data is being enriched and the agents are going and making decisions on top. 01:44:58.380 |
So what you can see here on the side is effectively the agentic logic that is reading, writing, analyzing, 01:45:06.380 |
and using all of this, let's say, preconfigured set of weights and benchmarks to analyze any person here. 01:45:16.380 |
You can ingest from any type of a data source. 01:45:22.380 |
You can build graphs from relational databases, semi-structured data. 01:45:25.380 |
And we also have this memory association layers inspired by the cognitive science approach. 01:45:30.380 |
And then effectively, as we kind of build and enrich this graph on the fly, we see that, you know, it's getting bigger. 01:45:39.380 |
And then we're storing the data back into the graph. 01:45:41.380 |
So this is the stateful temporal aspect of it. 01:45:45.380 |
We kind of build the graph in a way that we can add the data back, that we can analyze these reports, 01:45:50.380 |
that we can search them, and that we can let other agents access them on the fly. 01:45:54.380 |
The idea for us was let's have a place where agents can write and continuously add the data in. 01:45:59.380 |
So I'll have a look at the graph now so we can inspect the bits. 01:46:04.380 |
So if we click on any node, we can see the details about the commits, about the information from the developers, the PRs, whatever they did in the past, and which report they contributed to. 01:46:17.380 |
And then at the end, as the graph is pretty much filled, we will see the final report kind of starting to come in. 01:46:26.380 |
So it's taking, it's preparing now the final output for the hiring decision task. 01:46:32.380 |
So let's have a look at that when it gets loaded. 01:46:38.380 |
I hope to have a hosted version for you all today, but it didn't work. 01:46:51.380 |
Yes, so I will just show you the video with the end so we don't wait for it. 01:47:04.380 |
So here you can see that towards the end, we can see the graph. 01:47:11.380 |
And we can see the final decision, which is a green node. 01:47:18.380 |
And in the green node, we can see that we decided to hire Laszlo, our developer, who has a PhD in graphs. 01:47:25.380 |
So it's not really difficult to make that call. 01:47:27.380 |
And we see why and we see the numbers and the benchmarks. 01:47:35.380 |
And if you have some questions, I'm here afterwards. 01:47:49.380 |
So Vasilija showed us something I call semantic memory. 01:47:54.380 |
So basically you take your data, you load it and cognify it, as they like to say. 01:48:11.380 |
And next up is Alex will show us Neo4j MCP server. 01:48:26.380 |
I'm going to demo the memory MCP server that we have available. 01:48:33.380 |
So there is this walkthrough document that I have. 01:48:34.380 |
We'll make this available in the Slack or by some means so that you can do this on your own. 01:48:41.380 |
And what we're going to showcase today is really like the foundational functionality that we would 01:48:48.380 |
like to see in a agentic memory sort of application. 01:48:51.380 |
Primarily we're going to take a look at semantic memory in this MCP server. 01:48:54.380 |
But we are currently currently going to have a lot of time. 01:48:56.380 |
We're going to look at semantic memory in this MCP server. 01:48:59.380 |
But we are currently going to have a lot of time to see. 01:49:02.380 |
I'm going to look at semantic memory in this MCP server. 01:49:06.380 |
And we're going to add additional memory types as well, which we'll discuss probably 01:49:17.380 |
So, in order to do this, we will need a Neo4j database. 01:49:22.380 |
Neo4j is a graph native database that we'll be using to store our knowledge graph that we're 01:49:27.380 |
They have a Aura option which is hosted in the cloud. 01:49:31.380 |
Or we can just do this locally with the Neo4j desktop app. 01:49:35.380 |
Additionally, we're going to do this via cloud desktop. 01:49:41.380 |
And then we can just add this config to the MCP configuration file in Cloud. 01:49:47.380 |
And this will just connect to the Neo4j instance that you create. 01:49:53.380 |
Cloud will pull down the memory server from PyPy. 01:49:59.380 |
And then it will be able to use the tools that are accessible via the MCP server. 01:50:03.380 |
And the final thing that we're going to do before we can actually have the conversation 01:50:07.380 |
is we're just going to use this brief system prompt. 01:50:09.380 |
And what this does is just ensure that we are properly recalling and then logging memories 01:50:16.380 |
So, with that, we can take a look at a conversation that I had in Qua desktop using this memory server. 01:50:25.380 |
And so, this is a conversation about starting an agentic AI memory company. 01:50:31.380 |
And so, we can see all these tool calls here. 01:50:34.380 |
And so, initially, we have nothing in our memory store, which is as expected. 01:50:38.380 |
But as we kind of progress through this conversation, we can see that at each interaction, 01:50:44.380 |
it tries to recall memories that are related to the user prompt. 01:50:48.380 |
And then, at the end of this interaction, it will create new entities in our knowledge graph and relationships. 01:50:56.380 |
And so, in this case, an entity is going to have a name, a type, and then a list of observations. 01:51:03.380 |
And these are just facts that we know about this entity. 01:51:05.380 |
And this is what is going to be updated as we learn more. 01:51:10.380 |
In terms of the relationships, these are just identifying how these entities relate to one another. 01:51:16.380 |
And this is really the core piece of why using a graph database as sort of the context layer here is so important. 01:51:23.380 |
Because we can identify how these entities are actually related to each other. 01:51:31.380 |
And so, as this goes on, we can see that we have quite a few interactions. 01:51:35.380 |
We are adding observations, creating more entities. 01:51:38.380 |
And at the very end here, we can see we have quite a lengthy conversation. 01:51:43.380 |
We can say, you know, let's review what we have so far. 01:51:46.380 |
And so, we can read the entire knowledge graph back as context. 01:51:52.380 |
And so, we have all the entities we've found, all the relationships that we've identified, 01:51:56.380 |
and all the facts that we know about these entities based on our conversation. 01:52:00.380 |
And so, this provides a nice review of what we've discussed about this company and our ideas about how to create it. 01:52:12.380 |
And we can actually visualize this knowledge graph. 01:52:18.380 |
And if we click on one of these nodes, we can see that there is a list of observations that we have. 01:52:23.380 |
And this is all the information that we've tracked throughout that conversation. 01:52:27.380 |
And so, it's important to know that, like, even though this knowledge graph was created with a single conversation, 01:52:32.380 |
we can also take this and use it in additional conversations. 01:52:35.380 |
We can use this knowledge graph with other clients such as cursor IDE or Windsurf. 01:52:40.380 |
And so, this is really a powerful way to create a, like, memory layer for all of your applications. 01:53:03.380 |
I'll just assure personal beliefs about MCPs. 01:53:08.380 |
I was testing MCPs of Neo4j, Graffiti, Cogni, Mem0, just before the workshop. 01:53:16.380 |
And I'm a strong believer that this is our future. 01:53:21.380 |
And in a second, I will be showing a mini GraphRack chat arena. 01:53:26.380 |
And next up, something very, very important that Daniel does is temporal graphs. 01:53:34.380 |
They have 10,000 stars on GitHub and growing very fast. 01:53:52.380 |
So, I'm here today to tell you that there's no one-size-fits-all memory. 01:54:02.380 |
And why you need to model your memory after your business domain. 01:54:07.380 |
So, if you saw me a little bit earlier, and I was talking about Graffiti, Zepp's open-source temporal graph framework, you might have seen me just speak to how you can build custom entities and edges in the graffiti graph for your particular business domain. 01:54:27.380 |
So, business objects from your business domain. 01:54:30.380 |
So, business objects from your business domain. 01:54:31.380 |
What I'm going to demo today is actually how Zepp implements that and how easy it is to use from Python, TypeScript, or Go. 01:54:39.380 |
And what we've done here is we've solved the fundamental problem plaguing memory. 01:54:44.380 |
And we're enabling developers to build out memory that is far more cogent and capable for many different use cases. 01:54:57.380 |
So, I'm going to just show you a quick example of where things go really wrong. 01:55:03.380 |
So, many of you might have used ChatGPT before. 01:55:09.380 |
And you might have noticed that it really struggles with relevance. 01:55:13.380 |
Sometimes it just pulls out all sorts of arbitrary facts about you. 01:55:17.380 |
And, unfortunately, when you store arbitrary facts and retrieve them as memory, you get inaccurate responses or hallucinations. 01:55:26.380 |
And the same problem happens when you're building your own agents. 01:55:35.380 |
And it should remember things about jazz music, NPR, podcasts, the daily, et cetera. 01:55:43.380 |
But, unfortunately, because I'm in conversation with the agent or it's picking up my voice when I'm, you know, it's a voice agent. 01:55:50.380 |
It's learning all sorts of irrelevant things. 01:55:53.380 |
Like, I wake up at 7:00 a.m., my dog's name is Melody, et cetera. 01:55:57.380 |
And the point here is that irrelevant facts pollute memory. 01:56:04.380 |
They're not specific to the media player business domain. 01:56:08.380 |
And so, the technical reality here is, as well, that many frameworks take this really simplistic approach to generating facts. 01:56:17.380 |
If you're using a framework that has memory capabilities, agent framework, it's generating facts and throwing it into a vector database. 01:56:24.380 |
And, unfortunately, the facts dumped into the vector database or Redis mean that when you're recalling that memory, it's difficult to differentiate what should be returned. 01:56:33.380 |
We're going to return what is semantically similar. 01:56:37.380 |
And here we have a bunch of facts that are semantically similar to my request for my favorite tunes. 01:56:45.380 |
We have some good things and, unfortunately, Melody is there as well because Melody is a dog named Melody. 01:56:52.380 |
And that might be something to do with tunes. 01:57:01.380 |
So, basically, semantic similarity is not business relevance. 01:57:10.380 |
I was speaking a little bit earlier about how vectors are just basically projections into an embedding space. 01:57:17.380 |
There's no causal or relational relations between them. 01:57:25.380 |
We need domain aware memory, not better semantic search. 01:57:29.380 |
So, with that, I am going to, unfortunately, be showing you a video because the Wi-Fi has been absolutely terrible. 01:58:01.380 |
And it's asking me, well, how much do I earn a year? 01:58:07.380 |
It's asking me about what student loan debt I might have. 01:58:10.380 |
And we'll see that on the right-hand side, what is stored in Zepp's memory are some very explicit business objects. 01:58:24.380 |
We have financial goals, debts, income sources, et cetera. 01:58:33.380 |
And they're defined in a way which is really simple to understand. 01:58:45.380 |
So, let's go take a look at some of the code here. 01:58:48.380 |
We have a TypeScript financial goal schema using Zepp's underlying SDK. 01:58:57.380 |
We can give a description to the entity type. 01:58:59.380 |
We can even define fields, the business rules for those fields and the values that they take on. 01:59:05.380 |
And then we can build tools for our agent to retrieve a financial snapshot which runs multiple Zepp searches at the same time concurrently and filters by specific node types. 01:59:19.380 |
And when we start our Zepp application, what we're going to do is we're going to register these particular goals, sorry, objects with Zepp. 01:59:32.380 |
So, it knows to build this ontology in the graph. 01:59:40.380 |
I'm going to say that I have $5,000 a month rent. 01:59:50.380 |
And in a few seconds, we see that Zepp's already parsed that new message and has captured that $5,000. 02:00:03.380 |
And we can see the knowledge graph for this user has got a debt account entity. 02:00:10.380 |
It's got fields on it that we've defined as a developer. 02:00:15.380 |
And so, again, we can really get really tight about what we retrieve from Zepp by filtering. 02:00:22.380 |
So, just very quickly, we wrote a paper about how all of this works. 02:00:26.380 |
You can get to it by that link below and appreciate your time today. 02:00:40.380 |
So, once I'm getting ready, I would appreciate if you confirm with me whether you have access 02:00:52.380 |
So, I'd appreciate if you have any questions to any of the speakers. 02:01:02.380 |
And we are happy to answer more of these questions just after the workshop. 02:01:06.380 |
I, right now, move on with a use case that I developed and to this GraphRack chat arena. 02:01:15.380 |
To be specific, before delving into agentic memory, into knowledge graphs, I led a private 02:01:35.380 |
A very big client with very serious problems on the security side. 02:01:41.380 |
And I used to, in one project, I had to navigate between something like a 27, 29 different terminals 02:01:51.380 |
And I realized that LLMs are not only amazing to translate these languages, but they are also very good to kind of 02:02:05.380 |
But such shells, they would really be excellent if they have episodes. 02:02:21.380 |
of create a new type of shell, a human language shell. 02:02:26.920 |
But such shells, they would really be excellent 02:02:31.600 |
if they have episodic memory, the sort of temporal memory 02:02:36.600 |
of what was happening in this shell historically. 02:02:39.840 |
And if we have access to this temporal history, the events, 02:02:49.260 |
We kind of can control every single code execution function 02:02:52.680 |
that's running, including the ones of agents. 02:02:55.820 |
So I spotted with some investors and advisors of mine, 02:03:00.240 |
I spotted a niche, something we call agentic firewall. 02:03:04.940 |
And I wanted to do a super quick demo of how it would work. 02:03:08.540 |
So basically you would run commands and type pwd, 02:03:16.520 |
and in a sense, I suppose lots of us had computer science classes 02:03:24.140 |
And we have to remember all of these commands. 02:03:51.300 |
In general, I would need to know right now some command that can extract me, 02:04:09.900 |
for instance, the name of the container that's running and its status. 02:04:19.200 |
I can make mistakes, like human language, fuzzy mistakes. 02:04:28.540 |
All right, show the command we did three commands ago. 02:04:39.760 |
So basically if you plug in the agentic memory to things like that, I think it got it wrong, 02:04:54.520 |
So if I get through, like, different shells and terminals, and I have this textual context 02:05:01.600 |
of what was done, and the context of the certain machine of what is happening here, and it kind 02:05:10.020 |
of spans across all the machines, all the users, and all the sessions in PTYs, TTYs, I think 02:05:17.360 |
that we can really have a very good context also for security. 02:05:22.660 |
So that space, the temporal logs, the episodic logs, is something that I see will boom and 02:05:30.020 |
So I believe that all of our agents that will be executing codes in terminals will be executing 02:05:38.620 |
it through, maybe not all, but the ones that are running on the enterprise gate. 02:05:44.540 |
They will be going through agentic firewalls. 02:05:53.400 |
And now let's move on to GraphRack chat arena. 02:06:02.400 |
And this doc is allowing you to set up a repo that we've created for this workshop. 02:06:10.880 |
So about a year ago, I met with Jerry Liu from LamaLindex, and we were chatting quite a while 02:06:16.280 |
about how to evolve this conversational memory. 02:06:27.340 |
Data abstractions, I kind of quickly solved within, like, two months. 02:06:30.960 |
Evals, I realized that there wouldn't be any evals in form of a benchmark. 02:06:36.540 |
This, all of these hot potatoes and all of that, it's fun. 02:06:39.040 |
I know that there are great papers written by our guest speakers and other folks about hot 02:06:46.420 |
You can't do a benchmark for a thing that doesn't exist. 02:06:50.060 |
Basically, the agentic GraphRack memory will be this type of memory that evolves. 02:06:59.300 |
So if you don't know what will evolve, you will need a simulation arena. 02:07:08.420 |
So one year, fast forward, and we've created a prototype of such agentic memory arena. 02:07:15.840 |
Think about it like web arena, but for memory. 02:07:29.840 |
One approach will be sort of the repo, the library itself, and the other is through MCPs. 02:07:37.820 |
Because we don't really know what will work out better. 02:07:40.620 |
So whether repos or the MCPs will work out better. 02:07:42.920 |
So we need to test these different approaches. 02:07:53.980 |
So we get this nice chat where you can talk to these agents. 02:08:05.160 |
And there is a Neo4j agent running behind the scenes. 02:08:08.720 |
There is a Cypher graph agent running behind the scenes. 02:08:12.680 |
And I can kind of, for now, switch between these agents. 02:08:16.060 |
Maybe I'll increase the font size a little bit. 02:08:18.440 |
So the Neo agents basically answering the questions about this amazing technology, the graphs, specifically Neo4j. 02:08:27.160 |
And then an agent that is excellent at running Cypher queries talks with me. 02:08:40.360 |
And I'm passionate about memory architectures. 02:08:42.580 |
And basically, what it does is it runs these layers that are created by Cogni, by Memzero, by Graffiti, and all the other vendors of semantic and temporal memory solutions. 02:08:56.240 |
Or, specifically, created by an MCP server that Alex was demonstrating, the Neo4j MCP server. 02:09:05.720 |
So I'm really looking forward to how this technology evolves. 02:09:11.780 |
But what I really -- what I quickly wanted to show you is that it already works. 02:09:15.780 |
It has this science of being this agentic memory arena. 02:09:20.440 |
So I can ask my graph through questions, and the agent goes to the connection. 02:09:33.160 |
It's just one Neo4j graph on the backend, and all of these technologies that can be tested. 02:09:38.860 |
How the graphs are being created and retrieved. 02:09:42.100 |
It's like -- when I think of that, it's like the most brilliant idea that we can do with agentic memory simulations. 02:09:54.700 |
I can basically rerun the commands to see what's happening on this graph. 02:10:04.140 |
And next thing is I would like to add to the graph that Vasilio will show how to integrate 02:10:10.180 |
Cogni and ta-da-da-da, so I add new information. 02:10:20.600 |
But then I transfer it to graffiti, and I can repeat the exact same process. 02:10:26.000 |
So I can right now, using graffiti, search what I just added. 02:10:30.780 |
And I can switch between these different memory solutions. 02:10:36.320 |
And we do not have time to, like, practice it together, do the workshop, but I'm sure we'll 02:10:45.580 |
And I would appreciate, if you have any questions, pass them on to Slack. 02:10:50.520 |
I will ask Andreas whether we have time for a short Q&A or do we need to move it to, like, 02:11:06.680 |
I really would like Vasilya, Daniel, and Alex to come back to stage so you can ask any of 02:11:25.760 |
How do you decide what is a bad memory over time? 02:11:30.440 |
Because you could, like, as a developer and as a person, we evolve the line of thought, right? 02:11:36.920 |
So one thing that you thought was good, like, three years, ten years ago may not be good right 02:11:46.780 |
So I will answer in -- maybe you guys can help. 02:11:53.260 |
So basically the one that causes a lot of noise. 02:11:59.260 |
So you decrease noise by redundancy and by relationships. 02:12:05.160 |
So the less relationships and the more noisiness, the -- so in a sense, a not well-connected node 02:12:24.840 |
We will let you model the data with Pydantix so you can kind of load the data you need and 02:12:29.340 |
add weights to the edges and nodes so you can do something like temporal weighting. 02:12:33.880 |
You can add your custom logic and then effectively you would know how your data is kind of evolving 02:12:38.880 |
in time and then how it's becoming less or more relevant and what is the set of algorithms 02:12:45.980 |
Not solve it for you, but let's help you solve the tooling. 02:12:48.980 |
But, yeah, there is -- depends on the use case, I would say. 02:12:55.080 |
I think what I would add is that there is missing causal links. 02:12:59.280 |
Missing causal links is what is most probably a good indicator of fuzzy nice. 02:13:11.180 |
How would you embed in the security or privacy into the network or the application layer? 02:13:17.180 |
If there's a corporate, they have top secret data, or I have personal data that is a graph. 02:13:29.880 |
So basically, you do have to have that context. 02:13:32.600 |
You do have to have these decisions, intentions of colonels, of majors, and anyone like in 02:13:38.700 |
the enterprise -- like CISOs and anyone in the enterprise stack. 02:13:43.160 |
And in a sense, it also gets kind of like fuzzy and complex, so I expect this to be a very 02:13:50.640 |
But I'm sure that applying ontologies, the right ontologies, first of all, to this enterprise 02:13:55.920 |
cyber security stack and really kind of provides these guardrails for navigating this challenging 02:14:03.580 |
problem and decreasing this fuzziness and errors. 02:14:08.480 |
I would also just add, like, all these applications are built on Neo4j. 02:14:12.260 |
And so in Neo4j, you can, like, do role-based access controls, and so you can prevent users 02:14:18.700 |
from accessing data that they're not allowed to see. 02:14:21.100 |
So it's something that you can configure with that. 02:14:34.960 |
Kind of keep it, like, very physically separate. 02:14:45.620 |
Mark, in your earlier presentation, you mentioned this equation related gravity, entropy and something, 02:14:53.820 |
Could you show those two again and explain them again? 02:14:59.280 |
Other than that, it's probably for a series of papers to properly explain that. 02:15:07.320 |
The other one is that if you take all the attention, diffusion, and VAs which are doing 02:15:11.380 |
the smoothing, it preserves the sort of asymmetries. 02:15:15.520 |
So very briefly speaking, let's set up the vocabulary. 02:15:18.580 |
So first of all, curvature equals attention equals gravity. 02:15:22.800 |
This is the very simple, most important principle here. 02:15:26.060 |
I will need to, when writing these papers, we are really tightly trying to define these three. 02:15:36.640 |
And if it's not the exact same thing, if there are other definitions, we need to show what's 02:15:42.600 |
And now, if you think about attention, it kind of shows the sort of like pathways towards certain 02:15:50.880 |
If you take a sphere, if you start bending that sphere and make it like, you know, like 02:15:54.880 |
you kind of try to extend it, two things happen. 02:15:59.440 |
Entropy increases and curvature increases, in a sense. 02:16:03.080 |
And Perelman, what he did, he proved that you can like bend these spheres in any way, 3D 02:16:07.880 |
spheres, 4D and 5D and higher level spheres were already solved. 02:16:14.880 |
And these equations are proving that basically there won't be any other architectures for 02:16:20.880 |
It will be just attention diffusion models and VAs. 02:16:22.880 |
Maybe not just VAs, but like kind of like something that smooths, leaves room for biases. 02:16:37.880 |
And we'll answer the questions outside of the room. 02:16:46.880 |
We've got about maybe a 10-minute break before the next speaker is up. 02:17:00.880 |
Hi, if you are staying for the next session, I believe you have to go out and get your badge 02:17:04.880 |
scanned because that's how they keep track of how many people are at each session. 02:17:30.880 |
I like your way of presenting from another perspective. 02:17:33.880 |
Please go out and get your battery scanned if you're going to stay in the room. 02:17:52.880 |
I will be writing such like deep science, like theoretical physics papers. 02:17:53.880 |
First theoretical physics, then I mean, I have drafts that are being like reviewed. 02:17:59.880 |
It's, it's, it's, it's, it's really like, one second. 02:18:08.880 |
So it's really challenging to kind of question general relativity and it's like built on Perlman 02:18:32.880 |
It's just like, I, I only feel comfortable doing that when I have very good supervisor. 02:18:37.880 |
I basically, so the way it was, is I was starting with like Cogni and graffiti and Memzero. 02:18:43.880 |
We were like kind of like building things, but I was like, hi, I want to get into science. 02:18:53.880 |
I can probably write some posts about it briefly. 02:18:57.880 |
But what we are trying to do is like do this deep theoretical physics papers first. 02:19:03.880 |
And after that, so, so papers like one, two, three will be about that. 02:19:08.880 |
Papers like three, five will be about relating that to transformers, diffusion models, heat transfer, and all of these other things. 02:19:19.880 |
And in a sense, I, I, I feel like doing popular science, someone will take care of that. 02:19:47.880 |
Can you end mic? One second. Can you take it? Yeah. Thanks, Mike. Yeah. 02:20:46.140 |
Okay, so, he's gonna be on one, and he's on two. 02:20:52.140 |
Okay, go ahead and do the count back from five. 02:20:58.140 |
Hello, hello? Say five, four, three, two, one. 02:21:12.140 |
Ten, nine, eight, seven, five, six, five, four, three, two, one. 02:21:30.140 |
because we have to have to raise a certain way. 02:21:54.140 |
Okay, can I add some five for me? Five, four, three, two, one, zero. Okay, you know best. All right, thank you very much. 02:22:59.540 |
At the beginning you have all these slides about like the papers. Do we want to skip some of them? Because I had this like summary slide that had all the search stuff on one slide. How do you want to do it? Because it's like six slides. 02:23:15.700 |
Yes. I mean, I'm just going to click through them. Okay. So I'll go here, right? So from here, switch. She said we need to stay at the podium. So you have to step back and then I go here because of the live streaming. Okay. 02:23:29.480 |
Okay, so I'll just intro. I think we should be up here together for the intro. Yeah. But then if you don't want to stand here and watch me, then you can sit down. 02:23:46.340 |
Yeah. Do you have a clicker? No, I forgot mine at home. Do you have one? 02:24:01.340 |
No, I got one. Yeah, I got one. I mean, if the... 02:24:16.340 |
Oh, I think. Just one USB stick. One. Oh, USB A. 02:24:36.340 |
Hello, everyone. Hope you had some good coffee. Please come in. We are talking about graph rec today. That's the graph rec trick. 02:24:45.340 |
The graph rec trick, of course. And we want to look at patterns for successful graphic applications for making LLMs a little bit smarter by putting knowledge graph into the picture. 02:24:56.340 |
My name is Michael Hunger. I'm VP of product innovation at Neo4j. 02:25:00.340 |
My name is Steven Shin. I lead the developer relations at Neo4j. And actually, we're both co-authoring. This is fun because we're both already authors and finally we've been friends for years and we finally get to co-author a book. 02:25:14.340 |
We're also authoring graph rec, the definitive guide for O'Reilly. So basically, we didn't sleep this past weekend because we had a book deadline. 02:25:22.340 |
So I'm going to talk a little bit about kind of how to high level what graph rec is, why it's important, what we're seeing in the media. And then Michael's going to drill down into all of the details and patterns and give you a bunch of takeaways and things you can do. 02:25:36.340 |
This is probably, if you want to know how to do graph rec, Michael's quick deep dive on this is the best introduction you can get. So I'm also excited. 02:25:48.340 |
Okay. So the case for graph reg is where we're going to start. And the challenge with using LLMs and using other patterns for this is basically they don't have the enterprise domain knowledge. 02:26:01.340 |
They don't verify or explain the answers. They're subject to hallucinations. And they've ethical and data bias concerns. And you can see that very much like our friendly parrot here, they are all the things which parrots behave and act like, except a cute bird. 02:26:18.340 |
So we want to do better than this with graph reg and figure out how we can use domain specific knowledge, accurate, contextual and explainable answers. And really, I think like what a lot of companies and what the industry is figuring out is it's really a data problem. 02:26:34.340 |
You need good data. You need good data. You need to have data you can power your system with. One of the patterns you can do this with is RAG. So you can stick your external data into a RAG system. You can get stuff back from a database for the pattern. 02:26:49.340 |
But vector databases and RAG fall short because it's lacking kind of your full data set. It's only pulling back a fraction of the information by vector simulating algorithms. 02:27:01.340 |
Typically, a lot of the especially modern vector databases, which everyone's using, they're easy to start with, but they're not robust. They're not mature. They're not something which has scalability and fallback and gives you that what you need to get into build a strong, robust enterprise system. 02:27:17.340 |
And vector similarity is not the same as relevance. So results you get back from using a basic RAG system. They give you back things which are related to the topic, but it's not complete. 02:27:29.340 |
And it's typically also not very relevant. And then it's very hard to explain what's coming out of the system. 02:27:35.340 |
So we need to answer. Lifeline. Graphrag. And what Graphrag is, is we're bringing the knowledge and the context and the environment to what LMs are good at. 02:27:49.340 |
So you can think of this kind of like the human brain. Our left brain is, our right brain is more creative. It does more like building things. It does more extrapolation of information. 02:28:01.340 |
Whereas our left brain is the logical part. That's what actually has reasoning, has facts, and can enrich data. And it's built off of knowledge graphs. 02:28:09.340 |
So a knowledge graph is a collection of nodes, relationships, and properties. 02:28:15.340 |
Here's a really simple example of a knowledge graph where you have two people. They live together. You have a car. 02:28:21.340 |
But when you look into the details, it's actually like a little bit more complex than it seems at first. 02:28:25.340 |
Because they both have a car, but the owner of the car is not the person who drives it. 02:28:31.340 |
This is kind of like my family. My wife does all the bills, but then she hands me the keys whenever we get on the freeway. She hates driving. 02:28:40.340 |
So knowledge graphs also are a great way of getting really rich data. Here's an example of the Stack Overflow graph built into a knowledge graph where you can see all of the rich metadata and the complexity of the results. 02:28:52.340 |
And we can use this to evolve RAG into a more complex system, basically graph RAG, where we get better relevancy. 02:28:59.340 |
We're getting more relevant results. We get more context because now we can actually pull back all of the related information by graph closeness algorithms. 02:29:07.340 |
We can explain what's going on because it's no longer just vectors. It's no longer statistical probabilities coming out of a vector database. 02:29:15.340 |
We actually have nodes. We have structure. We have semantics we can look at. 02:29:18.340 |
And we can add in security and role-based access on top of this. 02:29:22.340 |
So it's context-rich. It's grounded. This gives us a lot of power. 02:29:26.340 |
And it gives us the ability to start explaining what we're doing, where now we can visualize it, we can analyze it, and we can log all of this. 02:29:34.340 |
Now, this is one of the initial papers, the graph RAG paper from Microsoft Research, where they went through this and they showed that you could actually get not only better results, but less token costs. 02:29:45.340 |
It was actually less expensive to do a graph RAG algorithm. 02:29:49.340 |
There have been a lot of papers since then which show all of the different research and interesting work which is going on in the graph RAG area. 02:29:59.340 |
And this is just a quick view of the different studies and results which are coming out. 02:30:03.340 |
But even from the early Data.World study where they showed a three times improvement in graph RAG capabilities. 02:30:09.340 |
And the analysts are even showing how graph RAG is trending up. 02:30:14.340 |
So this is the Gartner kind of hype cycle from 2024. 02:30:19.340 |
And you can see generic AI is kind of, you know, on the downtrends. 02:30:24.340 |
But graph RAG and a bunch of these things actually are providing and breathing more life into the AI ecosystem. 02:30:30.340 |
So a lot of great reports from Gartner showing that it's grounded in facts. 02:30:37.340 |
Together knowledge graphs and AI are solving these problems. 02:30:40.340 |
And it's getting a lot of adoption by different industry leaders. 02:30:43.340 |
By big organizations who are taking advantage of this and actually producing production applications. 02:30:49.340 |
And making it work like LinkedIn customer support where they actually wrote this great research paper. 02:30:55.340 |
Where they showed that using a knowledge graph for customer support scenarios actually gave them better results. 02:31:01.340 |
And allowed them to improve the quality and reduce the response time for getting back to customers. 02:31:08.340 |
Median per issue resolution time was reduced by 28.6%. 02:31:13.340 |
I mentioned the data.world study which basically was a comparison of doing RAG on SQL versus RAG on graph databases. 02:31:20.340 |
And they showed a three times improvement in accuracy of LLM responses. 02:31:26.340 |
Because I think everyone's here to learn how to do this. 02:31:33.340 |
So and if you look at graph RAG, that's actually two sides to the coin. 02:31:38.340 |
So one, of course, you don't start in a vacuum. 02:31:40.340 |
You have to create your knowledge graph, right? 02:31:42.340 |
And we see basically multiple steps to get there. 02:31:48.340 |
You put it into a lexical graph, which represents documents, chunks, and their relationships. 02:31:53.340 |
And the second step, you can then extract entities using, for instance, LLMs with this graph schema 02:31:59.340 |
to extract entities and the relationships from that graph. 02:32:02.340 |
And in the third phase, you would enrich this graph, for instance, with graph algorithms, 02:32:06.340 |
doing things like, you know, page rank, community summarization, and so on. 02:32:11.340 |
And then when you have this build-up knowledge graph, then you do graph REC as the search 02:32:18.340 |
Either with local search or global search and other ways. 02:32:23.340 |
So let's first look at the first phase of, like, knowledge graph construction a little bit. 02:32:28.340 |
So like, always in data engineering, there is, if you want to have higher quality outputs, 02:32:32.340 |
you have to put in more effort at the beginning. 02:32:37.340 |
But what you do at the beginning is basically paying off multiple times because what you get 02:32:42.340 |
out of your unstructured documents is actually high quality, high structured information, which 02:32:47.340 |
you then can use to extract contextual information for your queries, which allows 02:32:56.340 |
And so after seeing graph REC being used by a number of users customers, we've seen -- we 02:33:04.340 |
we saw that a number of patterns emerging in terms of like how we structure our graphs, 02:33:11.340 |
And so we started to collect these patterns and put them on graph REC.com. 02:33:15.340 |
And we want to -- I wanted to show what this looks like. 02:33:18.340 |
So we have basically example graphs in the pattern. 02:33:23.340 |
The pattern has a name, description, context, and we see also queries that are used for extracting 02:33:31.340 |
Let's look at the three steps in a little bit more detail on the graph model side. 02:33:42.340 |
So on one side, we have for lexical graph, you represent documents and the elements. 02:33:47.340 |
So that could be something simple as a chunk. 02:33:49.340 |
But if you have structured elements and documents, you can also do something like, okay, I have 02:33:53.340 |
a book which has chapters, which have sections, which have paragraphs, where the paragraph is 02:33:58.340 |
the semantically cohesive unit that you would use to, for instance, create a vector embedding 02:34:05.340 |
But what's really interesting in the graph is that you can connect these things all up, right? 02:34:09.340 |
So you know exactly who is the predecessor, who is the successor to a chunk, who is the parent 02:34:14.340 |
And using something like vector or text similarity, you can also connect these chunks as well by a 02:34:22.340 |
And then you can use all these relationships when you extract the context and the retrieval 02:34:37.340 |
phase to find what are related chunks by document, by temporal sequence, by similarity and other 02:34:47.340 |
So for instance, you have an RFP and you want to break it up in a structured way. 02:34:51.340 |
Then you basically create the relationships between these chunks or these subsections at the 02:34:57.340 |
text to the vector embeddings and then you do it at scale and then you get a full lexical 02:35:05.340 |
Next phase is entity extraction, which is also something that has been around for quite 02:35:13.340 |
But LLMs actually take this to the next level with the multi-language understanding, with 02:35:17.340 |
their high flexibility, good language skills for extraction. 02:35:20.340 |
So you basically provide a graph schema and an instruction prompt to the LLM plus your pieces 02:35:30.340 |
Now with large context windows, you can even put in $10,000, $100,000 tokens for extraction. 02:35:37.340 |
If you have, you can also put in already existing ground pools. 02:35:40.340 |
So for instance, if you have existing structure data where your entities, let's say products 02:35:45.340 |
or genes or partners or clients are already existing, then you can also put this in as part 02:35:52.340 |
So that the LLM doesn't do an extraction, but more an recognition and finding approach, 02:35:59.340 |
where you find the entities and then you extract the relationships from them and then you can 02:36:03.340 |
store additional facts and additional information that you store as part of relationships and 02:36:09.340 |
So basically in the first part you have the lexical graph, which is scripted on a document structure, 02:36:13.340 |
but in the second part you extract the relevant entities and their relationships. 02:36:18.340 |
If you have already an existing knowledge graph, you can also connect this to an existing 02:36:23.340 |
So imagine you have a CRM where you already have customer clients and leads in your knowledge 02:36:28.340 |
graph, but then you want to enrich this with, for instance, protocol from core transcripts 02:36:33.340 |
and then you basically connect this to your existing structure data as well. 02:36:38.340 |
And then in the next phase what you can do is you can run graph algorithms for enrichment, 02:36:43.340 |
which then, for instance, can do clustering on the entity graph and then you generate something 02:36:48.340 |
like communities where an LLM can generate summaries across them and such. 02:36:55.340 |
And for especially the last one, it's interesting because what you identify is actually cross document 02:37:01.340 |
So because it's basically each document is in a temporal vertical representation of information, 02:37:08.340 |
but what this is is actually it looks at which topics are here occurring across many different 02:37:14.340 |
So you find these kind of topic clusters across documents as well. 02:37:19.340 |
So if you look at the second phase, the search phase, which is basically the retrieval part 02:37:24.340 |
of red, what we see here is basically that in a graphic retriever, you don't just do a simple 02:37:31.340 |
vector lookup to get the results return, but what you do, you do an initial index search. 02:37:37.340 |
It could be vector search, full text search, hybrid search, spatial search, other kinds of searches 02:37:44.340 |
And then you basically can take, as you can see here, starting from these entry points, 02:37:49.340 |
you then follow the relationships up to a certain degree or up to a certain relevancy to fetch 02:37:56.340 |
And this context can be coming from user question. 02:37:59.340 |
It can be external user context that comes in, for instance, when someone from, let's say, 02:38:04.340 |
your finance department is looking at your data, you return different information than someone 02:38:09.340 |
from the, let's say, engineering department is looking at your data, right? 02:38:12.340 |
So you also take this external context into a column, how much in which context you retrieve. 02:38:17.340 |
And then you return to the LLM to generate the answer, not just basically text fragments 02:38:22.340 |
like you would do in vector search, but you also create the, return these more complete subset 02:38:29.340 |
of the, of the contextual graph to the LLM as well. 02:38:33.340 |
And modern LLMs are actually more trained on graph processing as well. 02:38:37.340 |
So they can actually deal with these additional pattern structures where you have node relationship, 02:38:43.340 |
node patterns that you provide as additional context to the LLM. 02:38:48.340 |
and then of course I mentioned that you can enrich it using graph algorithms so that you can do things 02:38:53.340 |
like clustering, link prediction, page rank and other things to enrich your data. 02:39:02.340 |
So one is knowledge graph construction from unstructured sources. 02:39:07.340 |
You've already heard some today from people that do these kind of things. 02:39:12.340 |
So one thing that you build is a tool that allows you to take PDFs, YouTube transcripts, 02:39:20.340 |
local documents, web articles, Wikipedia articles, and it extracts your data into a graph. 02:39:27.340 |
And let me just switch over to the demo here. 02:39:34.340 |
So I uploaded information from different Wikipedia pages, YouTube videos, articles, and so on. 02:39:41.340 |
And here is, for instance, a Google DeepMind extraction. 02:39:47.340 |
And then you can also, if you want to, in graph enhancement, provide graph schema as well. 02:39:52.340 |
So you can, for instance, say a person works for a company and add these patterns to your schema. 02:40:02.340 |
And then the LLM is using this information to drive the extraction as well. 02:40:07.340 |
And so if you look at the data that has been extracted from DeepMind, it's this one here. 02:40:14.340 |
We can actually see from the Wikipedia article two aspects. 02:40:19.340 |
One is the document with the chunks, which is this part of the graph, right? 02:40:24.340 |
And then the second part is the entities that have been extracted from this article as well. 02:40:29.340 |
So you see actually the connected knowledge graph of entities, which are companies, locations, 02:40:34.340 |
So it followed our, followed our schema to extract this. 02:40:39.340 |
And then if I want to run graph rec, you have here a number of different retrievers. 02:40:43.340 |
So we have vector retriever, graph and full text, entity retrievers, and others that you can select. 02:40:51.340 |
So you can just go to GitHub and have a look at this. 02:40:54.340 |
And so I just ran this before because internet is not so reliable here. 02:41:00.340 |
And then if I want to, I can here look at details. 02:41:04.340 |
So it shows me which sources that it used, alpha4, Google, Wikipedia, another PDF. 02:41:09.340 |
I see which chunks have been used, which is the full text and hybrid search. 02:41:13.340 |
But then I also see which entities have been used from the graph. 02:41:15.340 |
So I can actually really see from an explainability perspective, these are the entities that have 02:41:20.340 |
been retrieved by the graph rec retriever, passed to the LLM, in addition to the text that's 02:41:30.340 |
And then you can also do eval on that with as well. 02:41:36.340 |
So while I'm on the screen, let me just show you another thing that we worked on, which is 02:41:40.340 |
more like an energetic approach where you basically put these individual retrievers into a configuration 02:41:46.340 |
and configuration, where you have basically domain-specific retrievers that are running 02:41:54.340 |
So for instance, if you look at, let's say, this one, it has the query here. 02:42:00.340 |
And basically a tool with inputs and a description. 02:42:03.340 |
And then you can have an agentic loop using these tools, basically doing graphics with each 02:42:08.340 |
individual tool, taking the responses and then doing deeper tool calls. 02:42:20.340 |
This is all available as open source libraries. 02:42:26.340 |
Or it showed Neoconverse, which was able not just output text, but also charts and other 02:42:32.340 |
visualizations, networks, visualizations as well. 02:42:35.340 |
And what's interesting here in the agentic approach, you don't just use vector search to 02:42:40.340 |
retrieve your data, but you basically break down user question into individual tasks and 02:42:45.340 |
extract parameters and run these individual tools, which then are either run in sequence 02:42:50.340 |
or in a loop to return the data, and then you get basically these outputs back. 02:42:55.340 |
And then for each of these things, individual tools are called and used here. 02:43:01.340 |
And the last thing that I want to show is the graphic Python package, which is basically 02:43:06.340 |
also encapsulating all of the construction and the retrieval into one package. 02:43:11.340 |
So you can build a large graph, you can implement the retrieval and create the pipelines here. 02:43:16.340 |
And here's an example of where I pass in PDFs plus a graph schema and then basically it runs 02:43:24.340 |
the import into Neo4j and then I can, in the Python notebook, visualize the data later on. 02:43:30.340 |
And with that I leave you with, one second, the takeaway, which is on graphrack.com you find all of these resources, 02:43:40.340 |
a lot of the patterns and we'd love to have contributions and love to talk more. 02:43:46.340 |
I'm outside at the booth if you have more questions. 02:43:49.340 |
Yeah, so that was great and I think you're getting it all from the expert with all the tooling. 02:43:54.340 |
Actually, Michael's team builds a lot of the tools like Knowledge Graph Builder. 02:43:57.340 |
I'm very excited you all came to the graphrack track and hope to chat with you all more. 02:44:02.340 |
If you have questions for me and Michael, just meet us in the Neo4j booth across the way. 02:44:11.340 |
My big takeaway was that there is so much to look at. 02:44:24.340 |
My big takeaway was that there is so much to look at. 02:44:27.340 |
So in this next talk, who's going to be taking us through a multi-agent framework for network 02:45:48.660 |
So my presentation is going to be a little more producty than techy, 02:45:56.300 |
And so I've been at Cisco working on AI for the last three years, 02:46:06.960 |
Our charter is to help Cisco look at emerging technologies 02:46:10.840 |
and see how these emerging technologies can help us accelerate 02:46:13.500 |
the roadmaps of our traditional business units. 02:46:17.300 |
And so by training, I'm an electrical engineer, 02:46:21.760 |
doubled into network engineering, enjoyed it, 02:46:27.080 |
But over the last three years, focused on AI. 02:46:29.300 |
Our group also focuses on quantum technology, 02:46:32.640 |
so quantum networking is something that we're focused on. 02:46:34.940 |
And if you want to learn more about what we do with OutShift at Cisco, 02:46:42.360 |
So for today, we're going to dive into this real quick. 02:46:47.640 |
so I usually start with my customers' problems, 02:46:49.620 |
trying to understand what are they trying to solve for, 02:46:51.960 |
and then from that, walk backwards towards creating a solution for that. 02:47:05.320 |
and then we kind of deliver an MVP into a production environment. 02:47:11.040 |
that product graduates into the Cisco's businesses. 02:47:17.720 |
we have a lot of challenges with failures in production. 02:47:25.260 |
So we double-clicked on that problem statement, 02:47:27.500 |
and we realized it was a major problem across the industry. 02:47:29.980 |
I won't go into the details here, but it's a big problem. 02:47:35.340 |
we need to understand, does AI really have a place here, 02:47:38.100 |
or it's just going to be rule-based automation to solve this problem? 02:47:43.000 |
we realized that there are specific spots in the workflow 02:47:45.660 |
where AI agents can actually help address a problem. 02:47:48.760 |
And so we kind of highlighted three, four, and five, 02:47:51.520 |
where we believe that AI agents can help increase the value 02:47:55.000 |
for customers and reduce the pain points that they were describing. 02:48:00.880 |
We said, let's figure out a solution for this. 02:48:04.540 |
And so this solution consists of three big buckets. 02:48:07.320 |
The first one is the fact that it has to be a natural language interface 02:48:11.360 |
where network operations teams can actually interact with the system. 02:48:20.020 |
we built this system to talk to an ITSM tool such as ServiceNow. 02:48:23.980 |
So we actually have agents on the ServiceNow side talking to agents on our side. 02:48:27.880 |
The second piece of this is the multi-agent system that sits within this application. 02:48:32.900 |
So we have agents that are tasked at doing specific things. 02:48:36.360 |
So an agent that is tasked as doing impact assessments, doing testing, 02:48:40.260 |
doing reasoning around potential failures that could happen in the network. 02:48:44.980 |
And then the third piece of this is where we're going to spend some of the time today, 02:48:50.180 |
So we're having the concept of a digital twin in this case. 02:48:53.160 |
So what we're trying to do here is to build a twin of the actual production network. 02:48:57.060 |
And that twin includes a knowledge graph plus a set of tools to execute testing. 02:49:03.280 |
And so we're going to dive into that in a little bit. 02:49:05.960 |
But before we go into that, we had this challenge of, 02:49:09.760 |
okay, we want to build a representation of the actual network. 02:49:22.700 |
You have a variety of vendors in a customized environment, 02:49:26.440 |
a variety of devices, firewalls, switches, routers, and so on. 02:49:29.420 |
And all of these different devices are spitting out data 02:49:34.020 |
So the challenge for us is how can we create a representation of this real-world network 02:49:39.560 |
using knowledge graphs in a data schema that can be understood by agents. 02:49:43.860 |
And so the goal is for us to create this ingestion pipeline 02:49:49.680 |
that agents can take the right actions in a meaningful way and predictive way. 02:49:56.660 |
we had these three big buckets of things to consider. 02:50:00.200 |
So we had to think about what are the data sources going to be. 02:50:03.800 |
So if you, again, in networking, their controller systems, 02:50:06.780 |
their devices themselves, their agents in the devices, 02:50:12.420 |
all of these things are all collecting data from the network, 02:50:18.680 |
they're spitting it out in different languages, 02:50:24.820 |
And then in terms of how the data is actually coming out, 02:50:27.460 |
it could be coming out in terms of streaming telemetry, 02:50:33.480 |
How can we look at all of these three different considerations 02:50:36.520 |
and be able to come up with a set of requirements 02:50:40.820 |
that addresses the customer's pain point again? 02:50:49.240 |
a knowledge graph that can have multimodal flexibility, 02:50:57.860 |
you understand relationships across different entities in the network. 02:51:04.580 |
If an engineer is querying a knowledge graph, 02:51:11.860 |
no matter where the location of that node is. 02:51:16.000 |
The second thing was operational flexibility. 02:51:19.460 |
we can consolidate into one schema framework. 02:51:22.220 |
The fourth piece here is where the RAG piece comes into play. 02:51:27.220 |
So we've been hearing a little about graph RAG for a little bit today. 02:51:32.800 |
that has ability to have vector indexing in it 02:51:35.020 |
so that when you want to do semantic searches, 02:51:38.460 |
And then in terms of just ecosystem stability, 02:51:43.140 |
when we put this in the customer's environment, 02:51:44.620 |
there's not going to be a lot of heavy lifting 02:51:50.000 |
And again, he has to support multiple vendors. 02:51:52.080 |
So these were the requirements from a product side. 02:52:07.880 |
So I'm showing the table on the right-hand side. 02:52:09.900 |
It's not an exhaustive list of things that they considered, 02:52:12.520 |
but these were the things that they looked at 02:52:16.700 |
to address the requirements coming from product? 02:52:20.160 |
And we kind of all centered around the first two here, 02:52:32.980 |
There was kind of a recommendation system type of use cases 02:53:04.080 |
All of them are coming into this ingestion service, 02:53:18.040 |
because there's a lot of documentation about it 02:53:33.220 |
as a primary way for us to communicate with it. 02:53:57.380 |
or there's a decision to be made about a test, 02:54:04.760 |
You don't need to go to all of the layers of the graph. 02:54:30.160 |
and they're able to actually go to the right layer 02:54:36.740 |
of what the graph system looks like in layers.