WEBVTT

NOTE Sentence-level transcript of https://www.youtube.com/watch?v=g_NgCLTibiM

NOTE One cue per sentence. Cue ids are the line anchors on /transcripts/g_NgCLTibiM.html. A cue ends where the next begins, or 2 s after its last word.

s1
00:00:01.309 --> 00:00:03.309
[music]

s2
00:00:12.560 --> 00:00:14.720
Uh we're going to talk about graph engineering today.

s3
00:00:14.720 --> 00:00:18.200
How many people have heard about that term graph engineering?

s4
00:00:18.200 --> 00:00:19.879
Okay, so so fair amount of the room.

s5
00:00:19.879 --> 00:00:26.000
And then just so I understand, how many people here are familiar with Neo4j and have used Neo4j?

s6
00:00:26.000 --> 00:00:27.520
Okay, so we got a few people.

s7
00:00:27.520 --> 00:00:35.759
So that's good for uh just letting me know who we're talking to today.

s8
00:00:36.000 --> 00:00:41.360
Um so just some history on some of the verbage that's being used.

s9
00:00:41.360 --> 00:00:54.439
Uh there was a tweet that went out by Peter Steinberger, I think earlier this year in the summer, uh that talked about graph engineering and it was almost like is this sort of a new discipline that's happening as this evolution

s10
00:00:54.439 --> 00:00:57.560
from prompt engineering and context engineering.

s11
00:00:57.560 --> 00:01:00.520
Uh and there's a lot of hype around this.

s12
00:01:00.520 --> 00:01:04.239
Um and the name for this is new, but the mechanisms are not really new.

s13
00:01:04.239 --> 00:01:12.800
They we've always known in computer science generally about state machines and workflow graphs and knowledge graphs and all these different things.

s14
00:01:12.800 --> 00:01:18.120
What's changing is really how we think about them in reference to agents.

s15
00:01:18.120 --> 00:01:23.400
Um and what I'm going to talk to you about today is just how we think about graph engineering.

s16
00:01:23.400 --> 00:01:26.839
I'm going to offer you a little bit of a new perspective on this.

s17
00:01:26.839 --> 00:01:36.800
So if we actually try to define what graph engineering is, I think a good definition is it's just the practice of designing agent work as an explicit graph.

s18
00:01:36.800 --> 00:01:42.319
So where nodes do work and edges effectively route state between them.

s19
00:01:42.319 --> 00:01:47.120
And I tend to think of it in terms of three different types of graphs.

s20
00:01:47.120 --> 00:01:52.440
We have our general execution graphs, which you're probably very familiar with.

s21
00:01:52.440 --> 00:02:00.652
So these are the workflow graphs with routers and agents as actual nodes that happen within side of an agent harness.

s22
00:02:00.652 --> 00:02:05.612
But, there's other ways that we can think about graph engineering, too, that overlap with this.

s23
00:02:05.612 --> 00:02:07.972
So, that includes context graphs.

s24
00:02:07.972 --> 00:02:15.172
These are decision traces, instances of what's happened, and how it connects to other data inside of your domain.

s25
00:02:15.172 --> 00:02:19.092
And then there's also something that I'd call more procedural graphs.

s26
00:02:19.092 --> 00:02:32.972
So, this is almost like having a skill or procedural knowledge as a graph, where the steps might not be actual agents, but they might be steps inside of uh uh a way of doing something, basically a procedure.

s27
00:02:32.972 --> 00:02:42.652
So, different calls, maybe a step for a decision model, steps for different agents, whether to escalate, validation steps, and these sorts of things.

s28
00:02:42.652 --> 00:02:57.612
And I'm really going to focus on these last two, because I think we don't talk about them enough, and I think by understanding these, you can actually get a little bit at what the first graph is trying to do as well, but in a very portable and efficient way.

s29
00:02:57.612 --> 00:03:04.652
So, graph engineering lets agents really take on bigger, more complex work, and that's why we care about it.

s30
00:03:04.652 --> 00:03:16.732
And really, if you were to split it up, I think in terms of the benefits that a graph offers agents in this uh context, it would be predictability so being able to constrain a path that an agent takes,

s31
00:03:16.732 --> 00:03:32.092
making sure that the the answer is basically accurate from a task that it's doing um and having an explicit graph, the ability to govern, control, and guide what the agent does, and audit it, so you can understand what it's doing and make it better next time.

s32
00:03:32.092 --> 00:03:38.572
And then the third one, which is going to be interesting that we'll talk about, is how do we actually make graph engineering portable?

s33
00:03:38.572 --> 00:03:49.332
And instead of thinking about a graph as something that happens in the runtime, it could be something that you can store and actually move between different runtimes and have inside of a knowledge layer,

s34
00:03:49.332 --> 00:03:54.172
which gives you more interoperability and allows you to have a very simple stack.

s35
00:03:54.172 --> 00:03:58.692
Um and in the runtime, when we think about the graph, it's really like a piece of orchestration.

s36
00:03:58.692 --> 00:04:08.094
So, we're probably all of us or a large portion of us are probably familiar with LangGraph, ADK, um and all these other agent frameworks.

s37
00:04:08.094 --> 00:04:14.894
Um even to a certain extent Anthropic's multi-agent research and and some other stuff fits inside of graph engineering.

s38
00:04:14.894 --> 00:04:26.414
Um and what I'm going to talk about today is actually what happens when we take that sort of graph and we put it next to our data as context graphs and some other things that I was talking about before.

s39
00:04:26.414 --> 00:04:36.814
Um and really when you do this, as I was saying, you add this portability layer, you add the ability to take all of this knowledge and make it work

s40
00:04:36.814 --> 00:04:39.374
basically with any type of runtime.

s41
00:04:39.374 --> 00:04:41.734
So, that's what I'm going to go over today.

s42
00:04:41.734 --> 00:04:52.374
Um and this is what we're doing at Neo4j is we're defining this knowledge layer and this knowledge layer sits between systems of record that you would ordinarily retrieve data from.

s43
00:04:52.374 --> 00:04:55.774
So, Data Bricks, BigQuery, Snowflake, these types of places.

s44
00:04:55.774 --> 00:05:00.054
It could be documentation, it could be Obsidian, these these markdown files.

s45
00:05:00.054 --> 00:05:14.334
Um and then can we create standard protocols and artifacts that live inside of that layer that then you can take a graph engineering process and make it available to any runtime or any agent.

s46
00:05:14.414 --> 00:05:24.614
Um and the way our product works, just so you know at Neo4j, uh is we have our core database and then we have a ton of other AI stuff on top of it.

s47
00:05:24.614 --> 00:05:38.014
Uh so, the database and the analytics layer, um I'm going to be showing some of this throughout my talk, uh but what I'm really going to be focusing on is this top layer where we talk about sort of this agentic brain or these other memory tools

s48
00:05:38.014 --> 00:05:40.014
that wrap around the database.

s49
00:05:40.014 --> 00:05:44.934
So, just know that as I go through, I'm going to be showing you data being loaded into the database.

s50
00:05:44.934 --> 00:05:46.814
That's going to constitute our knowledge layer.

s51
00:05:46.814 --> 00:05:49.374
It's going to come from multiple different sources.

s52
00:05:49.374 --> 00:06:00.909
Um but a lot of the sort of extensions of that tooling and some of the experimental things that I'm going to show you exist as sort of this graph AI that hooks into that and loads data in and out of that thing.

s53
00:06:00.909 --> 00:06:01.734
[snorts]

s54
00:06:01.734 --> 00:06:12.215
Um, so, what we're doing at Neo4j, and kind of how we're thinking about this: we start with this concept of a context graph, which has different types of memory

s55
00:06:12.215 --> 00:06:25.455
from short-term memory which is going to be like your conversation history your long-term memory, being entities that are extracted from that or from your data, and then reasoning or decision trees inside of that.

s56
00:06:25.455 --> 00:06:35.935
And one of the interesting things that we've been looking at from a research perspective, and this really started out not so much at that graph, but actually at individual skill level.

s57
00:06:35.935 --> 00:06:45.735
There was a paper that we wrote earlier this year that we published in a workshop, and we were really trying to ask the question, can we take procedural knowledge,

s58
00:06:45.735 --> 00:06:53.615
whether it be from past decisions or even something like a skill like we have here, and compile it down to a graph?

s59
00:06:53.615 --> 00:07:07.135
And what we came up with was a process of taking written material, often a skill MD file, and the scripts and the references and assets, and moving that into an actual graph structure, which is what you see on that other side.

s60
00:07:07.135 --> 00:07:22.055
And the result of doing this and giving the agent the access to that graph structure, which has different nodes again representing inside of the skill decisions, different routing points, different scripts that have to be executed,

s61
00:07:22.055 --> 00:07:26.535
taking pros and compiling them down to to determine the six scripts.

s62
00:07:26.535 --> 00:07:34.735
When we do that and we force the agent to sort of run that graph, what we see is increases in uh task reward and performance.

s63
00:07:34.735 --> 00:07:37.095
So, this was uh from a while ago.

s64
00:07:37.095 --> 00:07:43.815
I I'm still [clears throat] working on updating it to the latest models, um but we were able to use a smaller model.

s65
00:07:43.815 --> 00:07:49.175
In this case, I think it was Sonnet, um, and now we're we're on to Haiku, as a matter of fact.

s66
00:07:49.175 --> 00:08:02.695
But, uh, we were seeing, even for really challenging tasks over diverse fields in physics and computer science and, um, various security, uh, physical training, a whole a whole ton of things,

s67
00:08:02.695 --> 00:08:08.175
um, is this overall increase in task reward, um, performance.

s68
00:08:08.175 --> 00:08:10.497
Then we were able to switch over to this.

s69
00:08:10.497 --> 00:08:21.977
And our PMs, uh, Will Lein, who works in our Labs team, actually took this idea and said, "Well, if we can do that with skills, maybe we can do it, too, with these memory graphs."

s70
00:08:21.977 --> 00:08:32.177
So, you can actually take that context graph that I was showing you earlier and distill a skill from that and have it still be connected in the same graph

s71
00:08:32.177 --> 00:08:35.817
over to all of your past decision traces and data.

s72
00:08:35.817 --> 00:08:41.336
And so, then you get those performance benefits, but you also have all this provenance that goes back from every step.

s73
00:08:41.336 --> 00:08:50.417
It's versioned, it's tracked, and you have governance over time where you can assess drift, you can understand where certain tool calls are coming from and their history.

s74
00:08:50.417 --> 00:08:56.937
A human can go through actually inside of NAMS, Neo4j Agent Memory Service, which is our reference architecture for this.

s75
00:08:56.937 --> 00:09:08.017
There's a QR code there, and there will be another one at the end, um, and be able to understand, like, exactly how this works, edit it, change it, do all sorts of cool stuff with it.

s76
00:09:08.017 --> 00:09:12.057
Um, so again, what we're talking about now are these artifacts that you can move around.

s77
00:09:12.057 --> 00:09:14.497
I mean, this thing makes a skill, right?

s78
00:09:14.497 --> 00:09:21.497
And so, any agent harness that can take that skill can now be running these graphs and doing all of this logic.

s79
00:09:21.537 --> 00:09:29.297
Um, and we have various customers that are using us for graph engineering types of tasks.

s80
00:09:29.297 --> 00:09:33.177
I'll go quickly because we're we're starting to run out of time.

s81
00:09:33.177 --> 00:09:42.857
Um, and even though they're not may not be using exactly the Labs project that they that we have, uh, we have consultancies which are working with other asset managers,

s82
00:09:42.857 --> 00:09:45.177
uh, for tough problems in compliance.

s83
00:09:45.177 --> 00:09:51.057
Uh, so being able to write audit reports, for example, where you have data that might come from multiple sources.

s84
00:09:51.057 --> 00:09:54.617
How do you automate that, but do it in a way that's governed and trustworthy?

s85
00:09:54.617 --> 00:09:57.057
So, you have compliance documentation.

s86
00:09:57.057 --> 00:10:03.097
You might have entities with different ticker symbols and names from different databases, and those all need to be resolved.

s87
00:10:03.097 --> 00:10:13.418
And so, giving your agent these graphs that express the logic that you need to do on besides the data basically allows you to automate those things in a trustworthy way.

s88
00:10:13.418 --> 00:10:18.618
Um and we have other people uh such as Uber that do this with configuration graphs.

s89
00:10:18.618 --> 00:10:31.658
Uh, so basically, if you have, um, you can imagine if you have drivers across the country, uh, compliance and regulations for different areas geographically vary greatly, um, and they come from this sprawl of microservices

s90
00:10:31.658 --> 00:10:38.298
that you need to pull data from to figure out like, "Okay, well, what is it for each area, for each component of a car, for example?"

s91
00:10:38.298 --> 00:10:47.178
Um and so being able to express that logic and have it sit aside the data um also helps them operationalize some of these things effectively.

s92
00:10:47.178 --> 00:10:50.258
So, I'm going to jump to a demo now.

s93
00:10:50.258 --> 00:10:56.778
It I'm going to warn you in advance: it's going to be quite a lot, and I'm going to jump through it kind of quickly, um, but it's very interesting.

s94
00:10:56.778 --> 00:11:08.178
And what I'm going to show you is how we can use that AIP library that I was talking about before, uh, to compile a skill and actually get a task that was not governed very well and took

s95
00:11:08.178 --> 00:11:14.378
very long to run, basically cut its cost by like 100% and then run it a lot, lot faster.

s96
00:11:14.378 --> 00:11:19.698
Um and of course, it's uh it's a demo, it's not a formal research proposal, but you can go there and look at the code.

s97
00:11:19.698 --> 00:11:22.218
It's all It's all very transparent.

s98
00:11:22.218 --> 00:11:29.298
Uh so, this is going to be an example for a loan um a loan approval process.

s99
00:11:29.298 --> 00:11:35.138
So, in a side of a loan approval process, there's lots of policies that have to be followed, obviously.

s100
00:11:35.138 --> 00:11:38.298
I'm not a financial expert, but many of you in the room are.

s101
00:11:38.298 --> 00:11:41.578
Um and so there's probably going to be a policy doc.

s102
00:11:41.578 --> 00:11:53.018
There's going to be a systems of steps that have to be followed exactly, and then you need your agent to be able to explain those steps very clearly, articulate them, and really get the answer right as if it was a human reviewing.

s103
00:11:53.018 --> 00:12:00.338
Um and the first thing you can do, like I was saying before, and I don't have time to probably run this all live, and the internet's going to be slow.

s104
00:12:00.338 --> 00:12:03.178
So, luckily I I have this preloaded.

s105
00:12:03.178 --> 00:12:09.898
Um and basically, the question that was asked was should we approve this new loan for this Rosa's Bakery business?

s106
00:12:09.898 --> 00:12:16.859
And in this case, you know, we have a business plan that's in a PDF that was uploaded.

s107
00:12:16.859 --> 00:12:22.779
Um and that is, let's see, um the business plan is the orange data.

s108
00:12:22.779 --> 00:12:26.299
So, if I was to scroll out here, you can see it here in the graph.

s109
00:12:26.299 --> 00:12:36.099
That connects also to data that we pulled from Data Bricks, from past transactions, lending policy data, and past decisions that were actually made.

s110
00:12:36.099 --> 00:12:47.579
And with that, the agent can crawl over all that information and basically realize that this person either had a loan before or there was a mistake before, something happened before,

s111
00:12:47.579 --> 00:12:53.563
and come up with an audit trail for that and basically post a solution uh very, very quickly.

s112
00:12:53.563 --> 00:12:53.739
[snorts]

s113
00:12:53.739 --> 00:12:55.899
Um and this is a great start.

s114
00:12:55.899 --> 00:13:02.779
Just in terms of like resolving data and being able to follow policies and understand how things connect, uh this is great.

s115
00:13:02.779 --> 00:13:07.619
One of the issues with this is, and I can show you a graph kind of of what this looks like.

s116
00:13:07.619 --> 00:13:11.259
This is an example of me running more of these policies.

s117
00:13:11.259 --> 00:13:16.459
Um and if I zoom in, I have a conversation here.

s118
00:13:16.459 --> 00:13:19.939
And then I have my my reasoning trace that exists inside of this graph.

s119
00:13:19.939 --> 00:13:23.579
And all of these steps are time-stamped and they have tool calls.

s120
00:13:23.579 --> 00:13:30.619
Uh what can happen is if I uh look at this happening twice.

s121
00:13:30.619 --> 00:13:32.659
I think this is the right query.

s122
00:13:32.659 --> 00:13:35.099
Um this is this is two decision chains.

s123
00:13:35.099 --> 00:13:36.459
It's going to be a little bit hard to see.

s124
00:13:36.459 --> 00:13:38.099
Let me zoom in.

s125
00:13:38.099 --> 00:13:41.219
Um they they're of different lengths, you'll notice.

s126
00:13:41.219 --> 00:13:43.979
So, one is longer than the other.

s127
00:13:43.979 --> 00:13:47.139
Um in this case, it was cuz it found a precedent in one.

s128
00:13:47.139 --> 00:13:50.099
Um basically, something else that had happened before.

s129
00:13:50.099 --> 00:13:58.939
But the the problem with this is that if you run these over and over again, there's nothing actually like enforcing that the agent follows an exact path.

s130
00:13:58.939 --> 00:14:02.539
You might have a skill or something that will say like do these things.

s131
00:14:02.539 --> 00:14:10.819
Uh but then there's other problems where it's like there's these decision steps where it's approve or deny is a simple one, or approve it or send to a human to review.

s132
00:14:10.819 --> 00:14:14.939
And those decision steps as well come with confidence scores.

s133
00:14:14.939 --> 00:14:21.061
Uh or you say like if you're confident about it, if you're not confident about something, but those decisions aren't calibrated.

s134
00:14:21.061 --> 00:14:30.141
So, it would be great to like even take some of this and send it to something like a type safe, you know, Jev type of model as well to be able to do some of those things.

s135
00:14:30.141 --> 00:14:37.581
So, what you can do is you can scrape all of this and you can compile it into a graph shape skill, which is what we did here.

s136
00:14:37.581 --> 00:14:41.781
And that graph shape skill, if I go here, you're not going to be able to see it.

s137
00:14:41.781 --> 00:14:45.541
But that's okay that you don't see a lot of the detail here.

s138
00:14:45.541 --> 00:14:56.701
The important part is that we sort of compiled all the information down from those successful runs that we did, even though they were a little bit inconsistent, and we put them into this graph YAML shape

s139
00:14:56.701 --> 00:14:58.181
inside of this skill.

s140
00:14:58.181 --> 00:15:07.901
And this skill, even though you probably have trouble seeing, has scripts, it has assets here, it has sometimes other reference resources.

s141
00:15:07.901 --> 00:15:09.661
It doesn't for this one.

s142
00:15:09.661 --> 00:15:15.021
It also has source documentation around the policy that you're supposed to do for the loan.

s143
00:15:15.021 --> 00:15:21.581
So, there's So, there's basically a ton of stuff in here for traceability, but then also telling the agent how to run the skill.

s144
00:15:21.581 --> 00:15:30.861
But the great thing is once the skill is in this YAML format, we can port it into all this different tooling, including inside of a graph, cuz it's all sort of this deterministic

s145
00:15:30.861 --> 00:15:32.301
format.

s146
00:15:32.301 --> 00:15:36.981
And in a graph, it looks kind of like this thing here.

s147
00:15:36.981 --> 00:15:40.941
So, let me Actually, let me just run this run this sucker again.

s148
00:15:40.941 --> 00:15:44.501
Um This is kind of what it looks like.

s149
00:15:44.501 --> 00:15:54.381
So, you have all of these steps out here, and then basically what I just did is I wrapped the small cli around this, so the agent can say, "Hey, run the skill."

s150
00:15:54.381 --> 00:15:59.581
And instead of the agent deciding all the routing steps, it's just done programmatically.

s151
00:15:59.581 --> 00:16:05.061
We took a lot of that policy down, and we put a lot of it into these execution scripts.

s152
00:16:05.061 --> 00:16:16.981
Basically, what's happening here, if if I was just to sum it up, there's an execution that basically looks at, "Hey, do do we meet certain hard rules around policies?"

s153
00:16:16.981 --> 00:16:25.622
After that, it's routed if it's not auto approved or denied based on that, it's routed to a decision model like Javelin type safe.

s154
00:16:25.622 --> 00:16:31.302
Um, and I can even probably show you a little bit of a clearer view here.

s155
00:16:31.302 --> 00:16:36.622
Um, and it's given that that model is given like a risk tier choice.

s156
00:16:36.622 --> 00:16:38.382
Um, let me make that a little bigger.

s157
00:16:38.382 --> 00:16:40.662
Hold on.

s158
00:16:41.702 --> 00:16:49.182
Um, whether or not there's there's some exposure material and then like an outcome of whether or not you're approving or denying.

s159
00:16:49.182 --> 00:16:57.902
And then the rest of this um, will basically follow down into writing a report, whether or not you need to escalate to a human review as this router.

s160
00:16:57.902 --> 00:17:04.501
And then if not, basically the agent is going to write a report and there's a circulation here to sort of check and lint that report.

s161
00:17:04.501 --> 00:17:12.982
Um, so once you do this and you sort of get the model going where okay, well now we have this cli that we can just run this thing in.

s162
00:17:12.982 --> 00:17:22.302
Um, well now I can go in here and then maybe I can probably don't have time to run this whole thing again, but I will give it a shot.

s163
00:17:22.302 --> 00:17:26.501
Um, I'll see if it goes and picks this up.

s164
00:17:26.501 --> 00:17:28.982
It takes about 2 minutes to run.

s165
00:17:28.982 --> 00:17:35.942
Uh, but the idea I guess while this is running and it should pick up the AIP scale which which it is here.

s166
00:17:35.942 --> 00:17:42.342
Um, once you have it in this format, not only can you have the agent run this very quickly.

s167
00:17:42.342 --> 00:17:43.742
Uh, you can track the runs.

s168
00:17:43.742 --> 00:17:51.662
So for example, um, if I was to look at a single run, I can run this again.

s169
00:17:51.662 --> 00:17:55.262
I can basically persist the runs inside of the graph.

s170
00:17:55.262 --> 00:18:00.262
Um, so this is a run of that scale with like individual steps that it ran.

s171
00:18:00.262 --> 00:18:03.502
Um, and then uh, I can just persist these over time.

s172
00:18:03.502 --> 00:18:05.062
I can examine how well they work.

s173
00:18:05.062 --> 00:18:10.382
So from a governance perspective, um, I have a little inspector here that I built really quickly.

s174
00:18:10.382 --> 00:18:12.902
You can look at the status of all these.

s175
00:18:12.902 --> 00:18:20.102
You can look at how a specific one ran, what was approved, what was denied inside of the process, what branches it took.

s176
00:18:20.102 --> 00:18:29.223
Um, and then once you have a graph, you can even do these cool observability things where you can ask, well, like what branches were taken and which branches weren't taken.

s177
00:18:29.223 --> 00:18:33.263
Um, which is very interesting from a governance perspective it failed ever [snorts].

s178
00:18:33.263 --> 00:18:38.143
Um, all these cool different things, and all of that is stored besides your data.

s179
00:18:38.143 --> 00:18:43.423
Um, and so in none of this, we're not like creating a loop, right, inside of our agent.

s180
00:18:43.423 --> 00:18:53.183
All we're doing here is basically giving it a cli to run this like programmatic skill that we compiled from documentation or in this case from our memory graph.

s181
00:18:53.183 --> 00:18:59.223
Um, and this might take a while to run just because of the the internet.

s182
00:18:59.223 --> 00:19:04.023
But what I will show you is I we ran this a few times.

s183
00:19:04.023 --> 00:19:12.583
Um, and what we saw is just running I was using Fable so my organization already yells at me for this enough so I'm spending a bunch of money.

s184
00:19:12.583 --> 00:19:20.783
Um, but like just using Fable alone on the graph and it was correct you know, pretty much every time but it took 2.7 minutes.

s185
00:19:20.783 --> 00:19:31.503
When we had the procedure it almost cut in half just using AIP and then because we had the procedure we can use a simpler model like Haiku and then we can cut the model time down even more and then of course,

s186
00:19:31.503 --> 00:19:33.703
you know, the cost just goes way down.

s187
00:19:33.703 --> 00:19:42.903
So, cuz you're taking all of that load, right, of having to figure out all the routing, all the stuff you're doing, you're putting into these execution scripts, these Java models and everything,

s188
00:19:42.903 --> 00:19:46.463
um which makes everything just much, much more efficient.

s189
00:19:46.463 --> 00:19:49.783
Um, and this is going to take too long to run.

s190
00:19:49.783 --> 00:19:52.503
Uh, it's mostly internet.

s191
00:19:52.503 --> 00:19:58.303
You can see here about half a minute or 2 minutes wall clock on average down from like 7 and 1/2.

s192
00:19:58.303 --> 00:20:01.783
All right, so anyway, um, I'll end it here.

s193
00:20:01.783 --> 00:20:06.823
So I want to give you some resources to check out if you're interested in this type of stuff.

s194
00:20:06.823 --> 00:20:11.543
Aura is our cloud service offering where you can get the database that I was showing you before.

s195
00:20:11.543 --> 00:20:13.823
You get $100 of free credits.

s196
00:20:13.823 --> 00:20:16.463
We have nodes coming up which are is speakers event.

s197
00:20:16.463 --> 00:20:25.705
There's a startup program and then all the code that I was referencing in the other projects that I was using to hook up to your agent memory, all that sort of stuff is down there.

s198
00:20:25.705 --> 00:20:32.865
So, I'll leave this up for a second until someone kicks me off, and I guess that's it for me for now.